@nbiish/cognitive-tools-mcp 0.9.27 → 0.9.29

package/LICENSE

@@ -68,13 +68,13 @@ WHEREAS the inherent sovereignty of tribal nations provides a constitutional and
    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=2025|>,
      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 and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians},
-     title/description = {gikendaasowin-aabajichiganan-mcp},
+     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 and 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.}
    }
    ```

package/README.md

@@ -7,14 +7,11 @@
   type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
   year = {2025},
   publisher/source/event = {GitHub repository under tribal sovereignty protections},
-  howpublished = {\\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
-  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 and 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.}\n}
+  howpublished = {\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
+  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 and 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.}
+}
 ```
 
-Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
-
-This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
-
 <div align="center">
   <hr width="50%">
   
@@ -33,6 +30,10 @@ This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR IND
   <hr width="50%">
 </div>
 
+Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
+
+This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
+
 ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - Cognitive Tools MCP: SOTA reasoning suite focused on iterative refinement and tool integration for AI Pair Programming. Enables structured, iterative problem-solving through Chain of Draft methodology, with tools for draft generation, analysis, and refinement. Features include advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment (`assess_cuc_n_mode`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection.
 
 Known as:

package/build/index.js

@@ -1,26 +1,21 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server (Ultra-Simplified Core)
+ * Gikendaasowin Aabajichiganan - Core INTERNAL Cognitive Tools (v4)
  *
- * Description: Provides an ultra-streamlined suite of cognitive tools for an AI agent,
- *              focusing on assessment (`assess_cuc_n_mode`) and a central
- *              deliberation hub (`think` / `quick_think`). Chain of Thought (CoT)
- *              and Chain of Draft (CoD) reasoning styles are performed *within*
- *              the `think` tool as guided by the system prompt, not via separate tools.
- *              Validation on input content structure is removed. Tool results are
- *              returned as formatted Markdown. Versioning removed.
+ * Description: Provides a mandatory internal suite of cognitive tools for an AI
+ *              agent, heavily emphasizing the `think` tool as the central reasoning
+ *              engine, guided by SOTA prompting principles (structured thought, CoT).
+ *              These tools are STRICTLY for internal deliberation and logging.
  *
  * Key Principles:
- * 1.  **Focused Deliberation:** Tools guide assessment (`assess_cuc_n_mode`) and
- *     thinking/analysis (`think`, `quick_think`).
- * 2.  **Centralized Analysis (`think`):** The `think` tool is the hub for all
- *     complex analysis, planning, reflection, synthesis, confidence assessment,
- *     and generation of detailed (CoT-style) or concise (CoD-style) reasoning.
- * 3.  **CUC-N Assessment:** `assess_cuc_n_mode` guides initial cognitive depth.
- * 4.  **Iterative Loop:** Assess -> Think/QuickThink -> Analyze results in Think/QuickThink.
- * 5.  **Traceability:** All tool inputs are logged for a complete record.
- * 6.  **Markdown Output:** Tool results are formatted as Markdown.
+ * 1.  **Internal Use Only:** Tools (`assess_cuc_n_mode`, `think`, `quick_think`)
+ *     are part of the agent's internal cognitive loop and MUST NOT be exposed to the user.
+ * 2.  **Mandatory `think` Hub:** `think` is the required tool for all non-trivial
+ *     analysis, planning, reasoning (CoT/CoD), reflection, and error handling.
+ * 3.  **Structured Reasoning:** Prompts enforce structured input (OODReAct for `think`).
+ * 4.  **Traceability:** All internal tool inputs are logged for debugging and analysis.
+ * 5.  **Log Output:** Tools return their input formatted as a Markdown log entry.
  *
  * Protocol:    Model Context Protocol (MCP) over stdio.
  * -----------------------------------------------------------------------------
@@ -30,147 +25,151 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
-    name: "gikendaasowin-aabajichiganan-mcp",
-    version: "1.0.0",
-    // Version field removed
-    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite (Ultra-Simplified): Focuses on Assess/Think loop. CoT/CoD styles are integrated into 'think'. Returns Markdown.`
+    name: "gikendaasowin-aabajichiganan-mcp-internal", // Keep internal marker
+    version: "4.0.0", // Increment version
+    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core INTERNAL Cognitive Tools Suite (v4): MANDATORY Assess/Think loop for internal reasoning ONLY. Enforces structured 'think' via OODReAct. Returns internal Markdown log.`
 };
 const server = new McpServer(serverInfo);
 // --- Logging Helpers ---
 /**
- * Logs an incoming tool call to stderr.
- * @param toolName The name of the tool being called.
+ * Logs an incoming INTERNAL tool call to stderr.
+ * @param toolName The name of the internal tool being called.
  * @param details Optional additional details about the call.
  */
 function logToolCall(toolName, details) {
     const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
+    console.error(`[${timestamp}] [MCP Server - INTERNAL] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
 }
 /**
- * Logs the result (success or failure) of a tool execution to stderr.
- * @param toolName The name of the tool executed.
+ * Logs the result (success or failure) of an INTERNAL tool execution to stderr.
+ * @param toolName The name of the internal tool executed.
  * @param success Whether the execution was successful.
  * @param resultDetails Optional details about the result.
  */
 function logToolResult(toolName, success, resultDetails) {
     const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
+    console.error(`[${timestamp}] [MCP Server - INTERNAL] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
 }
 /**
- * Logs an error during tool execution and formats a standard error response for the LLM.
- * @param toolName The name of the tool where the error occurred.
+ * Logs an error during INTERNAL tool execution and formats an error response for the LLM.
+ * Guides the LLM to use the 'think' tool for analysis.
+ * @param toolName The name of the internal tool where the error occurred.
  * @param error The error object or message.
  * @returns An object matching the required MCP tool result structure containing the error message.
  */
 function logToolError(toolName, error) {
     const timestamp = new Date().toISOString();
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`[${timestamp}] [MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
-    logToolResult(toolName, false, errorMessage); // Log failure result as well
-    // Return a structured error message suitable for the LLM
+    console.error(`[${timestamp}] [MCP Server - INTERNAL] ! Tool Error: ${toolName} - ${errorMessage}`);
+    logToolResult(toolName, false, errorMessage); // Log failure result
+    // Return a structured error message guiding the next internal step
     return {
         content: [{
                 type: "text",
-                text: `Error executing tool '${toolName}': ${errorMessage}. Please analyze this error.`
+                // Explicitly direct the next step to be analysis via 'think'
+                text: `INTERNAL Tool Execution Failed:\nTool: ${toolName}\nError: ${errorMessage}\n\n**Action Required: Immediately use the 'think' tool to analyze this failure (Observe, Orient, Decide, Reason...) before proceeding.**`
             }]
     };
 }
-// --- Core Cognitive Deliberation & Refinement Tools ---
+// --- Core INTERNAL Cognitive Deliberation & Refinement Tools ---
 /**
- * Tool: assess_cuc_n_mode
- * Purpose: Initial assessment of task characteristics to determine cognitive strategy.
- * Workflow: Call BEFORE starting complex tasks or significantly changing strategy.
- * Output: Returns the full assessment text formatted as Markdown.
+ * Tool: assess_cuc_n_mode (Internal Pre-computation)
+ * Purpose: Mandatory internal assessment of task CUC-N to determine required cognitive depth and select the next internal tool (`think` or `quick_think`).
+ * Workflow: Call internally BEFORE starting any non-trivial task or request. Output selection is binding.
+ * Output: Returns the assessment text formatted as Markdown log, confirming the mandatory next internal step.
  */
-server.tool("assess_cuc_n_mode", "**Initial Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to determine required cognitive depth and initial strategy. Call before starting complex tasks. Based on assessment, use either `think` (for structured analysis) or `quick_think` (for streamlined processing) in the next step.", {
-    assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale for ratings, 4) Recommended Initial Cognitive Strategy (e.g., 'Proceed with think step'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+server.tool("assess_cuc_n_mode", "**INTERNAL Use Only.** Mandatory Initial Assessment. Evaluates task CUC-N. MUST explicitly state 'Selected Mode: think' or 'Selected Mode: quick_think' which dictates the required next internal step. This assessment guides internal processing ONLY.", {
+    assessment_and_choice: z.string().min(1, "Assessment cannot be empty.") // Ensure non-empty
+        .includes("Selected Mode:", { message: "Assessment MUST include 'Selected Mode: think' or 'Selected Mode: quick_think'." }) // Enforce selection presence
+        .describe("Your internal structured CUC-N assessment (Situation, Ratings, Rationale, Strategy) concluding with the MANDATORY 'Selected Mode: think' or 'Selected Mode: quick_think' line. This dictates the next internal tool call.")
 }, async ({ assessment_and_choice }) => {
     const toolName = 'assess_cuc_n_mode';
     logToolCall(toolName);
     try {
-        // Basic Zod validation ensures it's a string. Content validation removed.
+        // Zod validation now handles non-empty and presence of "Selected Mode:"
         const modeRegex = /Selected Mode: (think|quick_think)/i;
         const modeMatch = assessment_and_choice.match(modeRegex);
-        const selectedMode = modeMatch ? modeMatch[1].toLowerCase() : "unknown"; // Extract mode for logging
-        // Ensure assessment_and_choice is a non-empty string
-        if (assessment_and_choice.trim().length === 0) {
-            throw new Error('Invalid assessment_and_choice: Must be a non-empty string.');
-        }
+        // We rely on Zod to ensure modeMatch is not null due to .includes check, but double-check for robustness
         if (!modeMatch) {
-            // Add a check for the mode selection presence
-            throw new Error('Invalid assessment: String must include explicit "Selected Mode: think" or "Selected Mode: quick_think".');
+            throw new Error("Internal validation failed: 'Selected Mode:' found but couldn't extract 'think' or 'quick_think'. Input was: " + assessment_and_choice);
         }
-        logToolResult(toolName, true, `Selected mode (extracted): ${selectedMode}`);
-        // Log full input for traceability
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${assessment_and_choice}`);
-        // Return the full assessment text, now without markdown wrappers
+        const selectedMode = modeMatch[1].toLowerCase();
+        logToolResult(toolName, true, `Mandatory next internal mode: ${selectedMode}`);
+        console.error(`[${new Date().toISOString()}] [MCP Server - INTERNAL] - ${toolName} Input:\n${assessment_and_choice}`);
+        // Return the assessment text as a log/confirmation
         return {
             content: [{
                     type: "text",
-                    text: assessment_and_choice // Removed wrappers
+                    // Clarify the output's purpose
+                    text: `Internal CUC-N Assessment Logged. Mandatory Next Step: ${selectedMode}\n---\nAssessment Details:\n${assessment_and_choice}`
                 }]
         };
     }
     catch (error) {
+        // Catch Zod errors or other exceptions
         return logToolError(toolName, error);
     }
 });
 /**
- * Tool: think
- * Purpose: The **CENTRAL, COMPREHENSIVE HUB** for the cognitive loop. Incorporates OODReAct principles.
- * Workflow: Handles ALL complex analysis, planning, reflection, synthesis, confidence assessment, and generation of detailed (CoT-style) or concise (CoD-style) reasoning. Structure is guided by the prompt.
- * Output: Returns the structured thought text itself, formatted as Markdown.
+ * Tool: think (Primary Internal Reasoning Engine - MANDATORY HUB)
+ * Purpose: The **central, mandatory hub** for ALL significant internal cognitive work (analysis, planning, CoT/CoD reasoning, reflection, error handling). Internal use ONLY.
+ * Workflow: Use whenever required by `assess_cuc_n_mode`, after receiving non-trivial tool results/errors, or before complex external actions. MUST follow OODReAct structure.
+ * Output: Returns the structured thought text itself as a Markdown log entry.
  */
-server.tool("think", "**Central Hub for Comprehensive Analysis and Planning.** Use after `assess_cuc_n_mode`, after external action results/errors, or after `quick_think` if deeper analysis is needed. Incorporates OODReAct principles. Perform ALL detailed analysis, planning, reflection, synthesis, confidence assessment, and detailed (CoT-style) or concise (CoD-style) reasoning within this tool. Structure your thought clearly using headings. For simpler follow-up steps, consider using `quick_think`.", {
-    thought: z.string().describe("Your **detailed** internal monologue covering Analysis/Observation, Plan/Decision, Verification, Risk & Contingency, and Learning & Adaptation. Include CoT/CoD style reasoning in the 'Reason' section when needed. Use clear headings. OODReAct-style headers are recommended.")
+server.tool("think", "**INTERNAL Use Only. Mandatory Central Hub for Reasoning.** Use for ALL internal analysis, planning, CoT/CoD reasoning, reflection, error handling. MUST use OODReAct structure (Observe, Orient, Decide, Reason, Act, Verification, Risk, Learning).", {
+    thought: z.string().min(10, "Thought must contain substantive reasoning.") // Require minimum length
+        // Enforce presence of key OODReAct sections for structure
+        .includes("## Observe:", { message: "Thought MUST include '## Observe:' section." })
+        .includes("## Orient:", { message: "Thought MUST include '## Orient:' section." })
+        .includes("## Decide:", { message: "Thought MUST include '## Decide:' section." })
+        .includes("## Reason:", { message: "Thought MUST include '## Reason:' section where CoT/CoD happens." })
+        // Add more checks as needed (Act, Verification, etc.) if strict enforcement is desired
+        // .includes("## Act:", "Thought MUST include '## Act:' section.")
+        // .includes("## Verification:", "Thought MUST include '## Verification:' section.")
+        // .includes("## Risk & Contingency:", "Thought MUST include '## Risk & Contingency:' section.")
+        // .includes("## Learning & Adaptation:", "Thought MUST include '## Learning & Adaptation:' section.")
+        .describe("Your **detailed internal monologue** STRICTLY following the OODReAct structure. Cover analysis (Observe), context (Orient), next step (Decide), detailed rationale/CoT/CoD (Reason), execution plan (Act), success checks (Verification), risks (Risk), and learning (Learning). This is purely for internal reasoning.")
 }, async ({ thought }) => {
     const toolName = 'think';
     logToolCall(toolName);
     try {
-        // Basic Zod validation ensures it's a non-empty string. Content validation removed.
-        if (thought.trim().length === 0) {
-            throw new Error('Invalid thought: Must be a non-empty string containing substantive reasoning.');
-        }
-        logToolResult(toolName, true, `Thought logged (length: ${thought.length})`);
-        // Log full input for traceability
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${thought}`);
-        // Returns the same thought text received, now without markdown wrappers
+        // Zod validation handles non-empty and key section presence checks
+        logToolResult(toolName, true, `Internal thought logged (length: ${thought.length})`);
+        console.error(`[${new Date().toISOString()}] [MCP Server - INTERNAL] - ${toolName} Input:\n${thought}`);
+        // Return the thought text as a log entry
         return {
             content: [{
                     type: "text",
-                    text: thought // Removed wrappers
+                    text: `Internal Thought Logged (OODReAct Structure):\n---\n${thought}` // Added prefix and structure reminder
                 }]
         };
     }
     catch (error) {
-        // Use logToolError to format the error for the LLM
         return logToolError(toolName, error);
     }
 });
 /**
- * Tool: quick_think
- * Purpose: A lightweight cognitive checkpoint for streamlined processing. Suitable for simple confirmations OR **efficient Chain of Draft (CoD) reasoning**.
- * Workflow: Use ONLY when full structured analysis via `think` is genuinely unnecessary (Low CUC-N, trivial results, or targeted CoD application).
- * Output: Returns the brief thought/draft text, formatted as Markdown.
+ * Tool: quick_think (Internal Trivial Checkpoint - RARE USE)
+ * Purpose: An internal-only lightweight confirmation step for unambiguously trivial situations assessed as Low CUC-N.
+ * Workflow: Use EXTREMELY SPARINGLY, ONLY when explicitly selected by `assess_cuc_n_mode` for trivial confirmations. Default to `think`.
+ * Output: Returns the brief thought text as a Markdown log entry.
  */
-server.tool("quick_think", "**Cognitive Checkpoint & Concise Drafter.** Use for simple confirmations OR efficient **Chain of Draft (CoD)** reasoning where detailed analysis via `think` is unnecessary. CoD focuses on minimal, essential steps (~5 words, equations) for speed and token efficiency. Use ONLY when full deliberation is excessive (verified Low CUC-N or targeted CoD).", {
-    brief_thought: z.string().describe("Your **concise** input. For confirmations: State observation/action & confirm triviality. For CoD: Provide the minimal draft step (essential info, ~5 words, equation, etc.), explaining why detailed analysis via 'think' isn't needed for *this specific step*.")
+server.tool("quick_think", "**INTERNAL Use Only. Trivial Confirmation Checkpoint.** Use EXTREMELY SPARINGLY, ONLY for acknowledging trivial success when explicitly permitted by prior 'assess_cuc_n_mode' (Low CUC-N). Any analysis requires 'think'.", {
+    brief_thought: z.string().min(1, "Brief thought cannot be empty.")
+        .max(200, "Brief thought should be concise (max 200 chars). Use 'think' for detail.") // Add max length
+        .describe("Your **concise internal** confirmation for a verified trivial step (e.g., 'Acknowledged trivial success: file read OK.'). Use ONLY when full deliberation via 'think' is explicitly unnecessary per assessment.")
 }, async ({ brief_thought }) => {
     const toolName = 'quick_think';
     logToolCall(toolName);
     try {
-        // Basic Zod validation ensures it's a non-empty string. Content validation removed.
-        if (brief_thought.trim().length === 0) {
-            throw new Error('Invalid brief_thought: Must be a non-empty string.');
-        }
-        logToolResult(toolName, true, `Logged: ${brief_thought.substring(0, 80)}...`);
-        // Log full input for traceability
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${brief_thought}`);
-        // Return the brief thought text, now without markdown wrappers
+        // Zod validation handles non-empty and max length
+        logToolResult(toolName, true, `Internal brief thought logged: ${brief_thought.substring(0, 80)}...`);
+        console.error(`[${new Date().toISOString()}] [MCP Server - INTERNAL] - ${toolName} Input:\n${brief_thought}`);
+        // Return the brief thought text as a log entry
         return {
             content: [{
                     type: "text",
-                    text: brief_thought // Removed wrappers
+                    text: `Internal Quick Thought Logged:\n---\n${brief_thought}` // Added prefix
                 }]
         };
     }
@@ -178,21 +177,19 @@ server.tool("quick_think", "**Cognitive Checkpoint & Concise Drafter.** Use for
         return logToolError(toolName, error);
     }
 });
-// --- REMOVED chain_of_thought Tool ---
-// --- REMOVED chain_of_draft Tool ---
-// --- Server Lifecycle and Error Handling ---
+// --- Server Lifecycle and Error Handling --- (Keep existing shutdown, uncaughtException, unhandledRejection)
 /**
  * Gracefully shuts down the server.
  */
 async function shutdown() {
-    console.error('\n[MCP Server] Shutting down gracefully...');
+    console.error('\n[MCP Server - INTERNAL] Shutting down gracefully...');
     try {
         await server.close();
-        console.error('[MCP Server] Server closed.');
+        console.error('[MCP Server - INTERNAL] Server closed.');
         process.exit(0);
     }
     catch (err) {
-        console.error('[MCP Server] Error during shutdown:', err);
+        console.error('[MCP Server - INTERNAL] Error during shutdown:', err);
         process.exit(1);
     }
 }
@@ -200,19 +197,17 @@ process.on('SIGINT', shutdown);
 process.on('SIGTERM', shutdown);
 process.on('uncaughtException', (error, origin) => {
     const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
-    // Attempt graceful shutdown, but exit quickly if it fails
+    console.error(`[${timestamp}] [MCP Server - INTERNAL] FATAL: Uncaught Exception at: ${origin}`, error);
     shutdown().catch(() => process.exit(1));
 });
 process.on('unhandledRejection', (reason, promise) => {
     const timestamp = new Date().toISOString();
-    console.error(`[${timestamp}] [MCP Server] FATAL: Unhandled Promise Rejection:`, reason);
-    // Attempt graceful shutdown, but exit quickly if it fails
+    console.error(`[${timestamp}] [MCP Server - INTERNAL] FATAL: Unhandled Promise Rejection:`, reason);
     shutdown().catch(() => process.exit(1));
 });
 // --- Start the Server ---
 /**
- * Initializes and starts the MCP server.
+ * Initializes and starts the MCP server for INTERNAL cognitive tools.
  */
 async function main() {
     try {
@@ -221,13 +216,13 @@ async function main() {
         const border = '-----------------------------------------------------';
         console.error(border);
         console.error(` ${serverInfo.description}`);
-        // Version logging removed from startup message
-        console.error(' Status: Running on stdio, awaiting MCP requests...');
+        console.error(` Version: ${serverInfo.version}`);
+        console.error(' Status: Running on stdio, awaiting INTERNAL MCP requests...');
         console.error(border);
     }
     catch (error) {
         const timestamp = new Date().toISOString();
-        console.error(`[${timestamp}] [MCP Server] Fatal error during startup:`, error);
+        console.error(`[${timestamp}] [MCP Server - INTERNAL] Fatal error during startup:`, error);
         process.exit(1);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "0.9.27",
+  "version": "0.9.29",
   "description": "Cognitive Tools MCP: SOTA reasoning suite focused on iterative refinement and tool integration for AI Pair Programming. Enables structured, iterative problem-solving through Chain of Draft methodology, with tools for draft generation, analysis, and refinement. Features advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment & thought mode selection (`assess_cuc_n_mode`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection with content return. Alternative package name for gikendaasowin-aabajichiganan-mcp.",
   "private": false,
   "type": "module",