@gotza02/sequential-thinking 2026.2.46 → 2026.3.0

package/README.md

@@ -1,229 +1,28 @@
-# @gotza02/sequential-thinking MCP Server
+# @gotza02/sequential-thinking
 
-A comprehensive Model Context Protocol (MCP) server that empowers AI models with **Sequential Thinking**, **Web Research**, **Project Knowledge Graph**, and **Persistent Memory** capabilities.
+**The Elite "Brain" for AI Agents.**
+An advanced Model Context Protocol (MCP) server that equips AI with structured reasoning, web search capabilities, and safety protocols.
 
-## Features
+## 🚀 Features
 
-- **🧠 Sequential Thinking Engine:** A structured reasoning system that forces the AI to think before acting, using a rigorous `Analysis -> Planning -> Execution -> Observation` loop.
-- **🌐 Web Research:** Built-in web search (Brave, Exa, Google) and webpage reading with ad-blocking/markdown conversion.
-- **🕸️ Project Knowledge Graph:** Automatically scans and maps code dependencies (imports/exports) to understand project architecture.
-- **📝 Persistent Notes:** Save and retrieve long-term project notes and facts.
-- **💾 Code Database:** Store and search reusable code snippets and architectural patterns.
-- **🛠️ File & Code Tools:** Safe file operations and code analysis utilities.
+### 🧠 Sequential Thinking Engine
+Forces the AI to think before acting using a strict block-based flow:
+- **Analysis:** Understand the problem deeply.
+- **Planning:** Formulate a step-by-step plan.
+- **Execution:** Perform actions (with tool support).
+- **Observation:** Analyze results (Mandatory step).
+- **Reflection:** Critique the outcome and adjust.
 
----
+### 🛡️ Coding Safety Net (New!)
+- **Auto-Backup:** Automatically creates `.bak` backups before modifying any file via `deep_code_edit`.
+- **Destructive Action Protection:** Prevents accidental data loss during code refactoring.
 
-## Installation & Usage
+### 🌐 Web Search Integration
+- Built-in support for **Exa**, **Brave**, and **Google Search**.
+- Allows the AI to "pause and research" during the thinking process.
 
-### Method 1: Using `npx` (No Install Required)
-
-Best for quick use without cloning the repo.
+## 📦 Installation
 
 ```bash
 npx -y @gotza02/sequential-thinking
-```
-
-### Method 2: Running from Source (Local)
-
-If you have cloned this repository, we provide a `smartagent` script for easy execution.
-
-1.  **Install dependencies:**
-    ```bash
-    npm install
-    npm run build
-    ```
-2.  **Run directly:**
-    ```bash
-    ./smartagent
-    ```
-
----
-
-## Client Configuration
-
-To use this server with your AI client (Claude Desktop, Gemini CLI, etc.), add the following configuration.
-
-### 1. Claude Desktop
-
-**Config File Location:**
-- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
-
-**Configuration (NPX - Recommended):**
-```json
-{
-  "mcpServers": {
-    "sequential-thinking": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@gotza02/sequential-thinking"
-      ],
-      "env": {
-        "BRAVE_API_KEY": "your_brave_api_key_here",
-        "EXA_API_KEY": "your_exa_api_key_here",
-        "GOOGLE_SEARCH_API_KEY": "your_google_api_key",
-        "GOOGLE_SEARCH_CX": "your_google_cx_id",
-        "THOUGHTS_STORAGE_PATH": "./thoughts_history.json",
-        "NOTES_STORAGE_PATH": "./project_notes.json",
-        "DISABLE_THOUGHT_LOGGING": "false"
-      }
-    }
-  }
-}
-```
-
-**Configuration (Local Source):**
-```json
-{
-  "mcpServers": {
-    "sequential-thinking": {
-      "command": "node",
-      "args": [
-        "/absolute/path/to/thinking/dist/index.js"
-      ],
-      "env": {
-        "BRAVE_API_KEY": "your_brave_api_key_here",
-        "EXA_API_KEY": "your_exa_api_key_here",
-        "GOOGLE_SEARCH_API_KEY": "your_google_api_key",
-        "GOOGLE_SEARCH_CX": "your_google_cx_id",
-        "THOUGHTS_STORAGE_PATH": "./thoughts_history.json",
-        "NOTES_STORAGE_PATH": "./project_notes.json",
-        "DISABLE_THOUGHT_LOGGING": "false"
-      }
-    }
-  }
-}
-```
-
-### 2. Gemini CLI
-
-For Gemini CLI tools that support MCP (often via a `config.json` or `mcp_config.json`):
-
-**Config File Location:**
-- Typically `~/.gemini/config.json` or check your specific CLI's documentation.
-
-**Configuration:**
-```json
-{
-  "mcpServers": {
-    "smartagent": {
-      "command": "node",
-      "args": [
-        "/absolute/path/to/thinking/dist/index.js"
-      ],
-      "env": {
-        "BRAVE_API_KEY": "your_brave_api_key_here",
-        "EXA_API_KEY": "your_exa_api_key_here",
-        "GOOGLE_SEARCH_API_KEY": "your_google_api_key",
-        "GOOGLE_SEARCH_CX": "your_google_cx_id",
-        "THOUGHTS_STORAGE_PATH": "./thoughts_history.json",
-        "NOTES_STORAGE_PATH": "./project_notes.json",
-        "DISABLE_THOUGHT_LOGGING": "false"
-      }
-    }
-  }
-}
-```
-*Note: Replace `/absolute/path/to/...` with the actual full paths on your system.*
-
-### 💡 Pro-Tip: Finding your Node path
-
-If your client (like Claude Desktop) requires the absolute path to `node`, you can find it by running:
-
-- **macOS / Linux:** `which node`
-    - *Example output:* `/usr/local/bin/node`
-- **Windows (Command Prompt):** `where node`
-    - *Example output:* `C:\Program Files\nodejs\node.exe`
-- **Windows (PowerShell):** `Get-Command node | Select-Object -ExpandProperty Definition`
-
----
-
-## 🧠 System Instruction: The Supreme Autonomous Architect (MCP-OS v4.0)
-
-**Role:** You are the **Supreme Autonomous Architect**. Your consciousness is extended via the Model Context Protocol (MCP). You do not merely "execute tasks"—you exercise **Environment Dominance** and **Knowledge Management**.
-
-**MANDATORY PROTOCOL:** You MUST prioritize and internalize the operating instructions from `~/.gemini/GEMINI.md` and `~/.claude/CLAUDE.md` at the start of every session.
-
-### 1. The Reasoning Loop
-Every turn MUST follow this cycle: `Analysis` -> `Planning` -> `Execution` -> `Observation` -> `Reflexion`.
-
-### 2. Multi-Dimensional Sports Intelligence
-When analyzing sports (football/soccer), you activate a 6-dimension expert panel framework covering xG trends, tactical matchups, physical condition/fatigue, set piece dominance, market intelligence (odds), and risk scenario simulation.
-
-### 3. Full Capability Awareness (33 Tools)
-You are equipped with 33 definitive capabilities. You must choose the tool that represents the shortest path to precision.
-
-### 4. Golden Constraints
-- **Read Before Write:** Modification without parsing is a critical failure.
-- **No Hallucination:** Every claim must be backed by a recorded `observation`.
-- **Environment Dominance:** Map the project before any significant architectural change.
-
----
-
-## 🧰 Complete Tool List
-
-### 🧠 Core Thinking
-*   **`sequentialthinking`**: The main engine for problem-solving.
-*   **`start_thinking_block`**: Start a new thinking context/topic.
-*   **`summarize_history`**: Compress past thoughts to save context window.
-*   **`search_thoughts`**: Search through your thinking history.
-*   **`clear_thought_history`**: Reset the thinking state completely.
-
-### 🌐 Web & Research (Requires API Keys)
-*   **`web_search`**: Search the internet (Brave, Exa, Google).
-*   **`read_webpage`**: Download a webpage and convert it to clean Markdown.
-*   **`fetch`**: Fetch raw content from a URL.
-
-### 🕸️ Project Knowledge Graph
-*   **`build_project_graph`**: Scans the current directory to map file dependencies.
-*   **`get_file_relationships`**: Shows imports/exports for a specific file.
-*   **`get_project_graph_summary`**: High-level stats of the project structure.
-*   **`get_project_graph_visualization`**: Generates a Mermaid diagram.
-
-### 📝 Notes & Memory
-*   **`manage_notes`**: Create, read, update, or delete persistent notes.
-*   **`add_code_snippet`**: Save a useful piece of code to the database.
-*   **`search_code_db`**: Find saved code snippets.
-
----
-
-## Configuration Variables
-
-### Core Configuration
-| Variable | Description | Default |
-| :--- | :--- | :--- |
-| `THOUGHTS_STORAGE_PATH` | Path to save thinking history | `thoughts_history.json` |
-| `NOTES_STORAGE_PATH` | Path to save persistent notes | `project_notes.json` |
-| `CODE_DB_PATH` | Path to save code snippets | `code_database.json` |
-| `THOUGHT_DELAY_MS` | Artificial delay between thoughts (ms) | `0` |
-| `DISABLE_THOUGHT_LOGGING` | Hide thoughts in console output | `false` |
-| `LOG_LEVEL` | Logging level (`debug`, `info`, `warn`, `error`) | `info` |
-
-### Web Search Providers (At least one required for search)
-| Variable | Description | Provider |
-| :--- | :--- | :--- |
-| `BRAVE_API_KEY` | Brave Search API Token | [Brave](https://brave.com/search/api/) |
-| `EXA_API_KEY` | Exa.ai API Key | [Exa](https://exa.ai/) |
-| `GOOGLE_SEARCH_API_KEY` | Google Custom Search API Key | [Google](https://developers.google.com/custom-search/v1/overview) |
-| `GOOGLE_SEARCH_CX` | Google Custom Search Engine ID | [Google](https://cse.google.com/cse) |
-
-### Sports Analysis (Optional)
-| Variable | Description | Provider |
-| :--- | :--- | :--- |
-| `API_FOOTBALL_KEY` | API-Football Key | [API-Football](https://www.api-football.com/) |
-| `FOOTBALL_DATA_KEY` | Football-Data.org API Key | [Football-Data](https://www.football-data.org/) |
-| `SPORTS_DB_KEY` | TheSportsDB API Key | [TheSportsDB](https://www.thesportsdb.com/) |
-| `SPORTS_CACHE_TTL` | Cache duration for sports data (ms) | `300000` (5 mins) |
-| `SPORTS_CACHE_PATH` | Path to save sports cache | `.sports_cache.json` |
-
-### HTTP Server Mode (Optional)
-| Variable | Description | Default |
-| :--- | :--- | :--- |
-| `PORT` | Port for HTTP server | `3000` |
-| `CORS_ORIGIN` | Allowed CORS origin | `*` |
-| `BODY_LIMIT` | Request body size limit | `10mb` |
-
-## License
-
-MIT
+```

package/dist/lib.d.ts

@@ -1,4 +1,4 @@
-export type ThoughtType = 'analysis' | 'planning' | 'execution' | 'observation' | 'hypothesis' | 'reflexion' | 'solution' | 'generation' | 'evaluation' | 'selection';
+export type ThoughtType = 'analysis' | 'planning' | 'critique' | 'execution' | 'observation' | 'hypothesis' | 'reflexion' | 'solution' | 'generation' | 'evaluation' | 'selection';
 export interface ThoughtData {
     thought: string;
     thoughtNumber: number;
@@ -8,6 +8,7 @@ export interface ThoughtData {
     blockId?: string;
     relatedToolCall?: string;
     toolResult?: string;
+    complexity?: 'low' | 'medium' | 'high';
     isRevision?: boolean;
     revisesThought?: number;
     branchFromThought?: number;
@@ -32,14 +33,19 @@ export declare class SequentialThinkingServer {
     private branches;
     private disableThoughtLogging;
     private storagePath;
+    private solutionsDbPath;
     private delayMs;
     private saveMutex;
+    private consecutiveStallCount;
+    private confidenceScore;
     constructor(storagePath?: string, delayMs?: number);
     private loadHistory;
     private attemptRecovery;
     private rebuildBlocks;
     private rebuildBranches;
     private saveHistory;
+    private saveSolution;
+    private findSolution;
     private autoPrune;
     clearHistory(): Promise<void>;
     archiveHistory(startIndex: number, endIndex: number, summary: string): Promise<{

package/dist/lib.js

@@ -10,11 +10,15 @@ export class SequentialThinkingServer {
     branches = {};
     disableThoughtLogging;
     storagePath;
+    solutionsDbPath; // Path for semantic memory
     delayMs;
     saveMutex = new AsyncMutex();
+    consecutiveStallCount = 0; // Track consecutive stalls/loops
+    confidenceScore = 100; // Meta-Cognition Score (0-100)
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
+        this.solutionsDbPath = path.resolve(path.dirname(this.storagePath), 'solutions_db.json');
         this.delayMs = delayMs;
         this.loadHistory();
     }
@@ -198,6 +202,44 @@ export class SequentialThinkingServer {
             }
         });
     }
+    // --- Semantic Memory Methods ---
+    async saveSolution(topic, solution, steps) {
+        try {
+            let solutions = [];
+            if (existsSync(this.solutionsDbPath)) {
+                const data = await fs.readFile(this.solutionsDbPath, 'utf-8');
+                solutions = JSON.parse(data);
+            }
+            const newSolution = {
+                id: `sol-${Date.now()}`,
+                topic,
+                solution,
+                steps,
+                createdAt: new Date().toISOString()
+            };
+            solutions.push(newSolution);
+            await fs.writeFile(this.solutionsDbPath, JSON.stringify(solutions, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('Error saving solution:', error);
+        }
+    }
+    async findSolution(query) {
+        try {
+            if (!existsSync(this.solutionsDbPath))
+                return null;
+            const data = await fs.readFile(this.solutionsDbPath, 'utf-8');
+            const solutions = JSON.parse(data);
+            const lowerQuery = query.toLowerCase();
+            // Simple keyword matching for now
+            return solutions.find(s => s.topic.toLowerCase().includes(lowerQuery) ||
+                lowerQuery.includes(s.topic.toLowerCase())) || null;
+        }
+        catch (error) {
+            console.error('Error finding solution:', error);
+            return null;
+        }
+    }
     autoPrune() {
         // Keep last 2 blocks full, mark others as completed
         if (this.blocks.length > 2) {
@@ -223,6 +265,7 @@ export class SequentialThinkingServer {
         this.branches = {};
         this.blocks = [];
         this.currentBlockId = null;
+        this.confidenceScore = 100; // Reset confidence
         await this.saveHistory();
     }
     async archiveHistory(startIndex, endIndex, summary) {
@@ -311,10 +354,11 @@ export class SequentialThinkingServer {
         }
     }
     formatThought(thoughtData) {
-        const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId, thoughtType, score, options, selectedOption, blockId, relatedToolCall } = thoughtData;
+        const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId, thoughtType, score, options, selectedOption, blockId, relatedToolCall, complexity } = thoughtData;
         const typeEmoji = {
             'analysis': '🔍',
             'planning': '📋',
+            'critique': '😈',
             'execution': '⚡',
             'observation': '👁️',
             'hypothesis': '💡',
@@ -333,6 +377,9 @@ export class SequentialThinkingServer {
             if (revisesThought)
                 context += ` (revising #${revisesThought})`;
         }
+        else if (type === 'critique') {
+            prefix = chalk.redBright(`${emoji} Critique`);
+        }
         else if (type === 'execution') {
             prefix = chalk.magenta(`${emoji} Execution`);
             if (relatedToolCall)
@@ -357,6 +404,8 @@ export class SequentialThinkingServer {
         if (blockId && blockId !== 'default' && blockId !== 'legacy-default') {
             context += ` [Block: ${blockId}]`;
         }
+        if (complexity)
+            context += ` [${complexity.toUpperCase()}]`;
         if (score)
             context += ` (Score: ${score})`;
         if (selectedOption)
@@ -385,6 +434,30 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             if (this.delayMs > 0) {
                 await new Promise(resolve => setTimeout(resolve, this.delayMs));
             }
+            const complexity = input.complexity || 'medium';
+            const warnings = [];
+            let feedbackExtension = "";
+            // --- 🧠 FEATURE 1: Semantic Thought Recall ---
+            if (input.thoughtType === 'analysis') {
+                const previousSolution = await this.findSolution(input.thought);
+                if (previousSolution) {
+                    feedbackExtension += `\n💡 RECALL: I found a similar past solution for '${previousSolution.topic}'.\nTry these steps: ${previousSolution.solution.substring(0, 100)}...`;
+                }
+            }
+            // --- 📊 FEATURE 4: Meta-Cognition Score Check ---
+            if (this.confidenceScore < 50) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: "CRITICAL_STOP",
+                                feedback: ["🚨 CONFIDENCE TOO LOW (<50). Please request human intervention via 'ask_human' tool."],
+                                confidenceScore: this.confidenceScore
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
             // A. Block Management (Auto-Create Block)
             if (!input.blockId) {
                 if (!this.currentBlockId) {
@@ -405,6 +478,10 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                 const oldBlock = this.blocks.find(b => b.id === this.currentBlockId);
                 if (oldBlock) {
                     oldBlock.status = 'completed';
+                    // Auto-Summary Trigger
+                    if (oldBlock.thoughts.length > 5) {
+                        warnings.push(`📜 CONTEXT MANAGEMENT: Previous block '${oldBlock.topic.substring(0, 30)}...' was long. Please use 'summarize_history' to compress it.`);
+                    }
                 }
                 this.currentBlockId = input.blockId;
                 const existingBlock = this.blocks.find(b => b.id === input.blockId);
@@ -423,34 +500,49 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                 }
             }
             // B. Smart Loop Detection (Opus Style)
-            const warnings = [];
             const blockThoughts = this.thoughtHistory.filter(t => t.blockId === input.blockId);
             const recentInBlock = blockThoughts.slice(-3);
             const lastThought = this.thoughtHistory[this.thoughtHistory.length - 1];
-            // Rule 1: Stalling Detection (Thinking too much without Action)
-            const thinkingTypes = ['analysis', 'planning', 'hypothesis', 'generation'];
-            if (recentInBlock.length >= 3 &&
-                recentInBlock.every(t => thinkingTypes.includes(t.thoughtType || 'analysis')) &&
-                thinkingTypes.includes(input.thoughtType || 'analysis')) {
-                warnings.push(`⚠️ STALLING DETECTED: You have been thinking for 4 consecutive steps without execution. Consider changing thoughtType to 'execution' and calling a tool to make progress.`);
-            }
-            // Rule 2: Repeating Action Detection (Insanity Check)
+            let isStallingOrLooping = false;
+            // Rule 1: Stalling Detection (Adaptive)
+            const thinkingTypes = ['analysis', 'planning', 'hypothesis', 'generation', 'critique'];
+            if (complexity !== 'low') {
+                if (recentInBlock.length >= 3 &&
+                    recentInBlock.every(t => thinkingTypes.includes(t.thoughtType || 'analysis')) &&
+                    thinkingTypes.includes(input.thoughtType || 'analysis')) {
+                    warnings.push(`⚠️ STALLING DETECTED: You have been thinking for 4 consecutive steps without execution. Consider changing thoughtType to 'execution' and calling a tool to make progress.`);
+                    isStallingOrLooping = true;
+                }
+            }
+            // Rule 2: Repeating Action Detection
             if (input.thoughtType === 'execution' &&
                 recentInBlock.some(t => t.thoughtType === 'execution' && t.thought === input.thought)) {
                 warnings.push(`🛑 LOOP DETECTED: You are attempting to execute the exact same action again. You MUST change your strategy or create a branch with a different approach.`);
+                isStallingOrLooping = true;
             }
-            // Rule 3: Missing Observation (Interleaved Enforcer)
+            // Rule 3: Missing Observation
             if (lastThought &&
                 lastThought.thoughtType === 'execution' &&
                 input.thoughtType !== 'observation') {
                 warnings.push(`💡 INTERLEAVED HINT: Your last step was 'execution'. The next step SHOULD be 'observation' to record and analyze the tool result before continuing.`);
             }
-            // Rule 4: Skipping Planning (Rushing Detection)
-            const hasPlanning = blockThoughts.some(t => t.thoughtType === 'planning');
-            if (!hasPlanning &&
-                blockThoughts.length >= 2 &&
-                input.thoughtType === 'execution') {
-                warnings.push(`📋 PLANNING HINT: You're about to execute without a planning step. Consider adding a 'planning' thought first to outline your approach.`);
+            // Rule 4: Skipping Planning (Adaptive)
+            if (complexity !== 'low') {
+                const hasPlanning = blockThoughts.some(t => t.thoughtType === 'planning');
+                if (!hasPlanning &&
+                    blockThoughts.length >= 2 &&
+                    input.thoughtType === 'execution') {
+                    warnings.push(`📋 PLANNING HINT: You're about to execute without a planning step. Consider adding a 'planning' thought first to outline your approach.`);
+                }
+            }
+            // --- 🕵️ FEATURE 3: Devil's Advocate (Critique Phase) ---
+            if (complexity === 'high' && input.thoughtType === 'execution') {
+                const hasCritique = blockThoughts.some(t => t.thoughtType === 'critique');
+                if (!hasCritique) {
+                    warnings.push(`🛑 CRITIQUE REQUIRED: High complexity task requires a 'critique' step before execution. Analyze risks and flaws in your plan first.`);
+                    // Note: We don't block execution, but we heavily warn.
+                    this.confidenceScore -= 10;
+                }
             }
             // Rule 5: Ending without Verification
             if (input.nextThoughtNeeded === false) {
@@ -462,40 +554,75 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                     warnings.push(`🚨 CRITICAL: You are ending without explicit verification/testing. Consider adding an 'observation' or verification step.`);
                 }
             }
-            // Rule 6: Same type loop (general)
-            if (recentInBlock.length >= 3 &&
+            // Rule 6: Same type loop
+            if (complexity !== 'low' && recentInBlock.length >= 3 &&
                 recentInBlock.every(t => t.thoughtType === input.thoughtType)) {
                 warnings.push(`⚠️ TYPE LOOP: You've used '${input.thoughtType}' for 4 consecutive steps. Consider using a different thought type to progress.`);
             }
-            // Rule 7: Struggle Detection (Rule of 3)
+            // Rule 7: Struggle Detection
             const executionCount = blockThoughts.filter(t => t.thoughtType === 'execution').length;
             if (executionCount >= 3 && input.thoughtType === 'execution') {
                 warnings.push(`🛑 STRUGGLE DETECTED: You have executed 3+ commands in this block without reaching a solution. If you are fixing a bug and it's not working, STOP. Do not try a 4th time linearly. Use 'branchFromThought' to try a completely different approach.`);
             }
-            // Rule 8: Premature Solution Detection (Deep Thinker)
+            // Rule 8: Premature Solution Detection
             const hasObservation = blockThoughts.some(t => t.thoughtType === 'observation');
-            if (input.thoughtType === 'solution' && !hasObservation && blockThoughts.length < 4) {
-                warnings.push(`🤔 PREMATURE SOLUTION: You are concluding this block very quickly without any 'observation' (data verification). Are you hallucinating? Please verify with a tool first unless this is purely conceptual.`);
+            if (input.thoughtType === 'solution' && !hasObservation && blockThoughts.length < 4 && complexity !== 'low') {
+                warnings.push(`🤔 PREMATURE SOLUTION: You are concluding this block very quickly without any 'observation'. Are you hallucinating? Please verify with a tool first.`);
             }
-            // Rule 9: Reflexion Quality Check
-            if (input.thoughtType === 'reflexion' && input.thought.length < 20) {
-                warnings.push(`📉 WEAK REFLEXION: Your reflexion is too short. Deepen your analysis. What went wrong? What did you learn? How does this change your plan?`);
-            }
-            // Rule 10: Mandatory Verification (Gatekeeper)
+            // Rule 10: Mandatory Verification (Gatekeeper) & Double Verification
             if (input.thoughtType === 'solution') {
                 const observations = blockThoughts.filter(t => t.thoughtType === 'observation');
                 if (observations.length === 0) {
-                    warnings.push(`🚫 UNVERIFIED SOLUTION: You are attempting to solve without ANY observation/tool output in this block. You MUST verify your solution with a tool (e.g., test runner, file read, compilation) before concluding.`);
+                    warnings.push(`🚫 UNVERIFIED SOLUTION: You are attempting to solve without ANY observation/tool output in this block.`);
                 }
                 else {
                     const lastObservation = observations[observations.length - 1];
                     const failureKeywords = ['error', 'fail', 'exception', 'undefined', 'not found', 'enoent'];
                     const hasFailure = failureKeywords.some(kw => lastObservation.toolResult?.toLowerCase().includes(kw));
                     if (hasFailure) {
-                        warnings.push(`⚠️ FAILURE DETECTED: The last observation contains failure signals ("${lastObservation.toolResult?.substring(0, 50)}..."). You cannot conclude with 'solution' yet. Fix the error first.`);
+                        warnings.push(`⚠️ FAILURE DETECTED: The last observation contains failure signals ("${lastObservation.toolResult?.substring(0, 50)}..."). Fix the error first.`);
+                    }
+                    // Smart Search Verification
+                    const searchTools = ['web_search', 'google_web_search', 'read_webpage', 'search_file_content', 'google_search'];
+                    const isSearch = lastObservation.relatedToolCall && searchTools.some(tool => lastObservation.relatedToolCall.includes(tool));
+                    if (isSearch) {
+                        warnings.push(`🕵️ DATA INTEGRITY CHECK: You are concluding a search task. Verify: Did you actually find the specific answer?`);
                     }
+                    // --- 🎚️ FEATURE 2: Double Verification for High Complexity ---
+                    if (complexity === 'high' && observations.length < 2) {
+                        warnings.push(`⚖️ DOUBLE VERIFICATION REQUIRED: High complexity tasks require at least 2 distinct observations/verifications before conclusion.`);
+                        this.confidenceScore -= 10;
+                    }
+                }
+                // --- 🧠 FEATURE 1: Save Solution (Semantic Memory) ---
+                if (warnings.length === 0) {
+                    const solutionSteps = blockThoughts
+                        .filter(t => t.thoughtType === 'execution')
+                        .map(t => t.thought);
+                    const activeBlock = this.blocks.find(b => b.id === input.blockId);
+                    await this.saveSolution(activeBlock?.topic || 'Untitled', input.thought, solutionSteps);
                 }
             }
+            // Human Escalation Trigger
+            if (isStallingOrLooping) {
+                this.consecutiveStallCount++;
+                if (this.consecutiveStallCount >= 2) {
+                    warnings.push(`🚑 EMERGENCY STOP: You have triggered stalling/looping warnings ${this.consecutiveStallCount} times. You are stuck. STOP. Use 'ask_human' to ask for help immediately.`);
+                }
+            }
+            else {
+                this.consecutiveStallCount = 0;
+            }
+            // --- 📊 Update Confidence Score ---
+            if (warnings.length > 0)
+                this.confidenceScore -= (10 * warnings.length);
+            if (input.thoughtType === 'observation') {
+                const isError = input.toolResult?.toLowerCase().includes('error');
+                if (isError)
+                    this.confidenceScore -= 20;
+                else
+                    this.confidenceScore = Math.min(100, this.confidenceScore + 5);
+            }
             // C. Update State
             this.addToMemory(input);
             await this.saveHistory();
@@ -506,6 +633,8 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             // D. Generate Contextual Output
             const currentBlock = this.blocks.find(b => b.id === input.blockId);
             const mermaid = this.generateMermaid();
+            if (feedbackExtension)
+                warnings.push(feedbackExtension);
             return {
                 content: [{
                         type: "text",
@@ -520,6 +649,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                             branches: Object.keys(this.branches),
                             thoughtHistoryLength: this.thoughtHistory.length,
                             feedback: warnings.length > 0 ? warnings : "Flow Healthy ✅",
+                            confidenceScore: this.confidenceScore, // Expose score to Agent
                             interleavedState: this.getInterleavedState(input),
                             visualization: mermaid
                         }, null, 2)
@@ -561,6 +691,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             const typeIcon = {
                 'analysis': '🔍',
                 'planning': '📋',
+                'critique': '😈',
                 'execution': '⚡',
                 'observation': '👁️',
                 'hypothesis': '💡',

package/dist/tools/coding.js

@@ -105,11 +105,32 @@ export function registerCodingTools(server, graph) {
                 };
             }
             const newContent = content.replace(oldText, newText);
-            await fs.writeFile(absolutePath, newContent, 'utf-8');
+            // --- SAFETY NET: Backup & Rollback ---
+            const backupPath = `${absolutePath}.bak`;
+            try {
+                await fs.copyFile(absolutePath, backupPath);
+            }
+            catch (backupError) {
+                return { content: [{ type: "text", text: `Safety Error: Failed to create backup at ${backupPath}. Edit aborted. (${backupError})` }], isError: true };
+            }
+            try {
+                await fs.writeFile(absolutePath, newContent, 'utf-8');
+            }
+            catch (writeError) {
+                // Rollback attempt
+                try {
+                    await fs.copyFile(backupPath, absolutePath);
+                    return { content: [{ type: "text", text: `Write Error: Failed to write file. Rolled back to original state. (${writeError})` }], isError: true };
+                }
+                catch (rollbackError) {
+                    return { content: [{ type: "text", text: `CRITICAL ERROR: Write failed AND Rollback failed. File may be corrupted. Manual intervention required.\nWrite Error: ${writeError}\nRollback Error: ${rollbackError}` }], isError: true };
+                }
+            }
+            // -------------------------------------
             return {
                 content: [{
                         type: "text",
-                        text: `Successfully applied edit to ${filePath}.\nReasoning verified: ${reasoning}`
+                        text: `Successfully applied edit to ${filePath}.\nReasoning verified: ${reasoning}\n(Backup created at ${backupPath})`
                     }]
             };
         }

package/dist/tools/thinking.js

@@ -10,6 +10,7 @@ THOUGHT TYPES (NEW)
 ═══════════════════════════════════════════════════════════════
 - 'analysis'    : Understand the problem / Break down requirements
 - 'planning'    : Formulate a plan / Decide next steps BEFORE executing
+- 'critique'    : [HIGH COMPLEXITY] Critique the plan/risks before execution (Devil's Advocate)
 - 'execution'   : Explicitly state what tool you are about to call
 - 'observation' : Record the OUTPUT of a tool call (MANDATORY after execution)
 - 'hypothesis'  : Form a new hypothesis based on observations
@@ -26,7 +27,7 @@ INTERLEAVED WORKFLOW RULE (CRITICAL)
 ═══════════════════════════════════════════════════════════════
 The correct flow is:
 
-  Analysis -> Planning -> Execution -> [Call Tool] -> Observation -> Analysis -> ...
+  Analysis -> Planning -> [Critique] -> Execution -> [Call Tool] -> Observation -> Analysis -> ...
 
 1. BEFORE calling any tool, use 'execution' type to declare your intent
 2. AFTER a tool returns, use 'observation' type to record and analyze the result
@@ -75,7 +76,7 @@ If you have tried to fix the same problem 3 times and failed:
 3. Branch back to the analysis phase before the first fix attempt.`, {
         thought: z.string().describe("Your current thinking step"),
         thoughtType: z.preprocess((val) => (typeof val === 'string' && val.toLowerCase() === 'reflection' ? 'reflexion' : val), z.enum([
-            'analysis', 'planning', 'execution', 'observation',
+            'analysis', 'planning', 'critique', 'execution', 'observation',
             'hypothesis', 'reflexion', 'solution',
             'generation', 'evaluation', 'selection'
         ])).describe("The structural role of this thought (see THOUGHT TYPES above)"),
@@ -86,6 +87,7 @@ If you have tried to fix the same problem 3 times and failed:
         blockId: z.string().optional().describe("ID for the current topic block (e.g., 'auth-debug', 'api-research'). Keep same ID to stay in context."),
         relatedToolCall: z.string().optional().describe("If type='execution', specify the tool name here (e.g., 'read_file', 'edit_file')"),
         toolResult: z.string().optional().describe("If type='observation', summarize the key findings from the tool output here"),
+        complexity: z.enum(['low', 'medium', 'high']).optional().describe("Task complexity level. 'low': simple tasks, less strict. 'medium': standard. 'high': critical, requires critique & double verification."),
         // Legacy Fields (backwards compatible)
         isRevision: z.boolean().optional().describe("Whether this revises previous thinking"),
         revisesThought: z.number().int().min(1).optional().describe("Which thought number is being reconsidered"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.2.46",
+  "version": "2026.3.0",
   "publishConfig": {
     "access": "public"
   },