@gotza02/sequential-thinking 2026.2.7 → 2026.2.9

package/README.md

@@ -1,17 +1,18 @@
 # Sequential Thinking MCP Server (Extended Edition) 🧠✨
 
-**MCP Server ที่ยกระดับ AI ให้เป็นวิศวกรซอฟต์แวร์อัจฉริยะ ด้วยระบบ Deepest Thinking และการวิเคราะห์ Codebase เชิงลึก**
+**MCP Server ที่ยกระดับ AI ให้เป็นวิศวกรซอฟต์แวร์อัจฉริยะ ด้วยระบบ Deepest Thinking, การวิเคราะห์ Codebase เชิงลึก และฐานข้อมูลความรู้ (Code Database)**
 
-โปรเจกต์นี้คือส่วนขยายขั้นสูงของ Sequential Thinking ที่รวมเอาความสามารถในการวางแผนที่เป็นระบบ, การหาข้อมูลทั่วโลก (Web Search), การสร้างแผนผังความสัมพันธ์ของโค้ด (Dependency Graph) และการจัดการหน่วยความจำระยะยาวเข้าด้วยกัน เพื่อให้ AI สามารถทำงานที่ซับซ้อนได้อย่างอิสระและแม่นยำ
+โปรเจกต์นี้คือส่วนขยายขั้นสูงของ Sequential Thinking ที่รวมเอาความสามารถในการวางแผนที่เป็นระบบ, การหาข้อมูลทั่วโลก (Web Search), การสร้างแผนผังความสัมพันธ์ของโค้ด (Dependency Graph), การจัดการหน่วยความจำระยะยาว และ **ฐานข้อมูลความรู้โค้ด (Code Database)** เข้าด้วยกัน เพื่อให้ AI สามารถทำงานที่ซับซ้อนได้อย่างอิสระและแม่นยำ
 
 ---
 
 ## 🌟 จุดเด่นของเวอร์ชัน Extended
 
 1.  **Deepest Thinking Protocol**: บังคับให้ AI วิเคราะห์ปัญหาแบบเป็นลำดับขั้นตอน (Step-by-step) พร้อมการแตกกิ่งความคิด (Branching) และการทบทวนตัวเอง (Reflexion) เพื่อหาทางเลือกที่ดีที่สุด
-2.  **Codebase Intelligence**: ระบบ `ProjectKnowledgeGraph` ที่ใช้ TypeScript Compiler API จริงๆ ในการสแกนความสัมพันธ์ระหว่างไฟล์และ Exported Symbols
-3.  **Deep Coding Workflow**: เครื่องมือใหม่สำหรับการแก้ไขโค้ดที่ต้องผ่านการวิเคราะห์บริบท (Context Document) และการวางแผนที่ผ่านการตรวจสอบเหตุผลแล้วเท่านั้น
-4.  **Optimized Web Extraction**: ระบบอ่านเว็บที่ตัดโฆษณาและส่วนที่ไม่จำเป็นออก (Readability) แปลงเป็น Markdown เพื่อประหยัด Token และให้ข้อมูลที่สะอาดที่สุด
+2.  **Codebase Intelligence**: ระบบ `ProjectKnowledgeGraph` ที่ใช้ TypeScript Compiler API และ Regex (สำหรับ Python/Go) ในการสแกนความสัมพันธ์ระหว่างไฟล์และ Exported Symbols
+3.  **Code Database (CodeStore)**: ระบบจัดเก็บ Snippets และ Architectural Patterns ลงในไฟล์ JSON ถาวร ช่วยให้ AI "จดจำ" วิธีแก้ปัญหาและนำกลับมาใช้ใหม่ได้
+4.  **Deep Coding Workflow**: เครื่องมือใหม่สำหรับการแก้ไขโค้ดที่ต้องผ่านการวิเคราะห์บริบท (Context Document) และการวางแผนที่ผ่านการตรวจสอบเหตุผลแล้วเท่านั้น
+5.  **Smart Notes**: ระบบบันทึกที่มี **Priority Level** และ **Expiration Date** ช่วยจัดลำดับความสำคัญของงานได้ดียิ่งขึ้น
 
 ---
 
@@ -25,7 +26,9 @@
 | `GOOGLE_SEARCH_CX` | Google Custom Search Engine ID (CX) | ❌ (Optional) |
 | `THOUGHTS_STORAGE_PATH` | ไฟล์เก็บประวัติความคิดเพื่อใช้ต่อเนื่อง | `thoughts_history.json` |
 | `NOTES_STORAGE_PATH` | ไฟล์เก็บความจำระยะยาว (กฎโปรเจกต์, ความชอบ) | `project_notes.json` |
+| `CODE_DB_PATH` | ไฟล์เก็บฐานข้อมูลความรู้โค้ด (Snippets/Patterns) | `code_database.json` |
 | `THOUGHT_DELAY_MS` | เวลาหน่วงระหว่างคิด (เพื่อความสมจริงและการจัดการ Rate Limit) | `0` |
+| `LOG_LEVEL` | ระดับการแสดงผล Log (debug, info, warn, error) | `info` |
 
 ---
 
@@ -39,31 +42,24 @@
 ### 💻 2. Deep Coding & Codebase Context
 *   **`deep_code_analyze`**: 🌟 **(ใหม่)** สร้าง Codebase Context Document รวบรวมเนื้อหาไฟล์, Symbols และความสัมพันธ์ (Import/Export) เพื่อให้ AI "เรียนรู้" ก่อนแก้โค้ด
 *   **`deep_code_edit`**: 🌟 **(ใหม่)** แก้ไขโค้ดแบบ Surgical Edit โดยต้องระบุ `reasoning` (เหตุผลเชิงลึก) ที่ผ่านการคิดวิเคราะห์มาแล้ว
-*   **`build_project_graph`**: สแกนโปรเจกต์เพื่อสร้างแผนผังความสัมพันธ์ทั้งหมด
+*   **`build_project_graph`**: สแกนโปรเจกต์เพื่อสร้างแผนผังความสัมพันธ์ทั้งหมด (รองรับ TS, JS, PY, GO)
 *   **`get_file_relationships`**: ตรวจสอบว่าไฟล์เป้าหมายกระทบกับส่วนไหนของระบบบ้าง
 *   **`search_code`**: ค้นหา Code Pattern ทั้งโปรเจกต์แบบชาญฉลาด
 
-### 🌐 3. External Research
+### 📚 3. Knowledge & Memory (CodeStore)
+*   **`add_code_snippet`**: 🌟 **(ใหม่)** บันทึก Snippet โค้ดที่ใช้งานบ่อยลงฐานข้อมูล
+*   **`search_code_db`**: 🌟 **(ใหม่)** ค้นหาความรู้เดิมจากฐานข้อมูล (ช่วยลดเวลาในการเริ่มงานใหม่)
+*   **`learn_architecture_pattern`**: 🌟 **(ใหม่)** บันทึกรูปแบบโครงสร้างของระบบ
+*   **`manage_notes`**: (ปรับปรุงใหม่!) จัดการบันทึกพร้อมระบุ **Priority** และ **Expiration**
+
+### 🌐 4. External Research
 *   **`web_search`**: ค้นหาข้อมูลล่าสุดจากโลกภายนอก (Brave/Exa/Google)
 *   **`read_webpage`**: อ่านเนื้อหาเว็บแปลงเป็น Markdown ที่สะอาดและเข้าใจง่าย
 *   **`fetch`**: ดึงข้อมูล Raw จาก API ต่างๆ
 
-### 📁 4. System & Persistence
+### 📁 5. System & Persistence
 *   **`read_file` / `write_file` / `edit_file`**: จัดการไฟล์ในระบบ
-*   **`shell_execute`**: รันคำสั่ง Terminal (เช่น Build, Test, Deploy)
-*   **`manage_notes`**: จัดการหน่วยความจำระยะยาวข้ามเซสชัน
-
----
-
-## 🔄 The "Deep Coding" Workflow (ขั้นตอนการทำงานที่แนะนำ)
-
-เพื่อให้ AI ทำงานได้อย่างเทพที่สุด แนะนำให้ใช้ลำดับการทำงานดังนี้:
-
-1.  **Map the Codebase**: รัน `build_project_graph` เพื่อให้ AI เข้าใจโครงสร้างโปรเจกต์ทั้งหมด
-2.  **Deep Analysis**: ใช้ `deep_code_analyze` กับไฟล์ที่เกี่ยวข้อง เพื่อสร้างบริบทและความเข้าใจ symbols ที่ใช้งาน
-3.  **Strategic Planning**: ใช้ `sequentialthinking` เพื่อวางแผนแบบ Deepest Thinking (แตกกิ่งความคิด, ทดสอบสมมติฐาน)
-4.  **Precision Edit**: ลงมือแก้ไขด้วย `deep_code_edit` หรือ `edit_file` พร้อมระบุเหตุผลที่วิเคราะห์มาแล้ว
-5.  **Verify**: ใช้ `shell_execute` รันคำสั่ง Test หรือ Lint เพื่อตรวจสอบความถูกต้อง
+*   **`shell_execute`**: รันคำสั่ง Terminal (มีระบบป้องกันคำสั่งอันตราย เช่น `rm -rf /`)
 
 ---
 
@@ -93,7 +89,7 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
     ```bash
     npm run build
     ```
-4.  **Configuration**: เปิดไฟล์ตั้งค่า AI Client ของคุณ (เช่น `~/.gemini/settings.json`) แล้วเพิ่มการตั้งค่า MCP Server โดยอ้างอิง Path ไปยังโฟลเดอร์ที่ Build เสร็จแล้ว
+4.  **Configuration**: ตั้งค่า AI Client ตามตัวอย่างด้านล่าง
 
 ---
 
@@ -117,6 +113,7 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
         "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_SEARCH_ENGINE_ID",
         "THOUGHTS_STORAGE_PATH": "thoughts_history.json",
         "NOTES_STORAGE_PATH": "project_notes.json",
+        "CODE_DB_PATH": "code_database.json",
         "THOUGHT_DELAY_MS": "1000",
         "DISABLE_THOUGHT_LOGGING": "false"
       }
@@ -139,6 +136,7 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
         "EXA_API_KEY": "YOUR_EXA_KEY",
         "GOOGLE_SEARCH_API_KEY": "YOUR_GOOGLE_API_KEY",
         "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_SEARCH_ENGINE_ID",
+        "CODE_DB_PATH": "code_database.json",
         "THOUGHT_DELAY_MS": "1000"
       }
     }
@@ -150,6 +148,16 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
 
 ---
 
+## 🛠️ ติดตั้งคำสั่งระบบ (System Instruction Setup)
+
+คุณสามารถติดตั้งคำสั่งระบบ **Ultimate Deep Engineer** ให้กับ Gemini และ Claude ได้โดยอัตโนมัติด้วย Script นี้:
+
+```bash
+chmod +x install-ultimate-engineer.sh && ./install-ultimate-engineer.sh
+```
+
+---
+
 ## 🤖 Recommended System Instruction (The Ultimate Deep Engineer)
 
 ให้ Copy ข้อความด้านล่างนี้ไปใส่ใน **System Prompt** ของ AI Agent เพื่อประสิทธิภาพสูงสุด:
@@ -164,6 +172,7 @@ You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP
 - **Atomic Analysis:** Use `thoughtType: 'analysis'` to break every request into atomic requirements and constraints before proposing solutions.
 - **Mandatory Reflexion:** Use `thoughtType: 'reflexion'` frequently to critique your own logic, identify potential edge cases, and challenge your assumptions.
 - **Tree of Thoughts:** For critical architectural decisions, use branching to explore multiple paths (Conservative vs. Aggressive) and evaluate them using `thoughtType: 'evaluation'`.
+- **Loop Breaker:** If a bug persists after 2 attempts or reasoning loops, MUST create a new branch (`branchFromThought`) to change strategy completely.
 - **Verified Completion:** Only set `nextThoughtNeeded: false` when the solution is definitive, verified, and follows project standards.
 
 ## 🏗 CODEBASE INTELLIGENCE PROTOCOL
@@ -185,6 +194,7 @@ You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP
 
 ## 📝 PERSISTENT MEMORY
 - **Long-term Knowledge:** Use `manage_notes` to save architectural decisions, user preferences, project conventions, and "lessons learned" that must persist across sessions.
+- **Code Database:** Use `add_code_snippet` to store reusable patterns and `search_code_db` to retrieve them.
 - **Session Continuity:** Your thought history is saved. If you restart, review the history to maintain context.
 ```
 

package/dist/codestore.js

@@ -0,0 +1,57 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class CodeDatabase {
+    filePath;
+    db = { snippets: [], patterns: {} };
+    loaded = false;
+    constructor(storagePath = 'code_database.json') {
+        this.filePath = path.resolve(storagePath);
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            this.db = JSON.parse(data);
+        }
+        catch (error) {
+            this.db = { snippets: [], patterns: {} };
+        }
+        this.loaded = true;
+    }
+    async save() {
+        await fs.writeFile(this.filePath, JSON.stringify(this.db, null, 2), 'utf-8');
+    }
+    async addSnippet(snippet) {
+        await this.load();
+        const newSnippet = {
+            ...snippet,
+            id: Math.random().toString(36).substring(2, 9),
+            updatedAt: new Date().toISOString()
+        };
+        this.db.snippets.push(newSnippet);
+        await this.save();
+        return newSnippet;
+    }
+    async searchSnippets(query) {
+        await this.load();
+        const q = query.toLowerCase();
+        return this.db.snippets.filter(s => s.title.toLowerCase().includes(q) ||
+            s.description.toLowerCase().includes(q) ||
+            s.tags.some(t => t.toLowerCase().includes(q)) ||
+            s.code.toLowerCase().includes(q));
+    }
+    async learnPattern(name, description) {
+        await this.load();
+        this.db.patterns[name] = description;
+        await this.save();
+    }
+    async getPattern(name) {
+        await this.load();
+        return this.db.patterns[name] || null;
+    }
+    async listAllPatterns() {
+        await this.load();
+        return this.db.patterns;
+    }
+}

package/dist/index.js

@@ -4,12 +4,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { SequentialThinkingServer } from './lib.js';
 import { ProjectKnowledgeGraph } from './graph.js';
 import { NotesManager } from './notes.js';
+import { CodeDatabase } from './codestore.js';
 import { registerThinkingTools } from './tools/thinking.js';
 import { registerWebTools } from './tools/web.js';
 import { registerFileSystemTools } from './tools/filesystem.js';
 import { registerGraphTools } from './tools/graph.js';
 import { registerNoteTools } from './tools/notes.js';
 import { registerCodingTools } from './tools/coding.js';
+import { registerCodeDbTools } from './tools/codestore.js';
 const server = new McpServer({
     name: "sequential-thinking-server",
     version: "2026.2.6",
@@ -17,6 +19,7 @@ const server = new McpServer({
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 const knowledgeGraph = new ProjectKnowledgeGraph();
 const notesManager = new NotesManager(process.env.NOTES_STORAGE_PATH || 'project_notes.json');
+const codeDb = new CodeDatabase(process.env.CODE_DB_PATH || 'code_database.json');
 // Register tools
 registerThinkingTools(server, thinkingServer);
 registerWebTools(server);
@@ -24,6 +27,7 @@ registerFileSystemTools(server);
 registerGraphTools(server, knowledgeGraph);
 registerNoteTools(server, notesManager);
 registerCodingTools(server, knowledgeGraph);
+registerCodeDbTools(server, codeDb);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/notes.js

@@ -23,13 +23,15 @@ export class NotesManager {
     async save() {
         await fs.writeFile(this.filePath, JSON.stringify(this.notes, null, 2), 'utf-8');
     }
-    async addNote(title, content, tags = []) {
+    async addNote(title, content, tags = [], priority = 'medium', expiresAt) {
         await this.load();
         const note = {
             id: Date.now().toString(36) + Math.random().toString(36).substring(2, 7),
             title,
             content,
             tags,
+            priority,
+            expiresAt,
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString()
         };
@@ -37,12 +39,20 @@ export class NotesManager {
         await this.save();
         return note;
     }
-    async listNotes(tag) {
+    async listNotes(tag, includeExpired = false) {
         await this.load();
+        const now = new Date();
+        let activeNotes = this.notes;
+        if (!includeExpired) {
+            activeNotes = this.notes.filter(n => !n.expiresAt || new Date(n.expiresAt) > now);
+        }
         if (tag) {
-            return this.notes.filter(n => n.tags.includes(tag));
+            return activeNotes.filter(n => n.tags.includes(tag));
         }
-        return this.notes;
+        return activeNotes.sort((a, b) => {
+            const priorityMap = { 'critical': 4, 'high': 3, 'medium': 2, 'low': 1 };
+            return (priorityMap[b.priority] || 0) - (priorityMap[a.priority] || 0);
+        });
     }
     async searchNotes(query) {
         await this.load();

package/dist/system_test.js

@@ -0,0 +1,51 @@
+import { NotesManager } from './notes.js';
+import { CodeDatabase } from './codestore.js';
+import * as fs from 'fs/promises';
+async function testSystem() {
+    console.log("🚀 Starting System Logic Test...\n");
+    // --- 1. Testing Notes Manager (Priority & Expiration) ---
+    console.log("--- Testing Notes Manager ---");
+    const notes = new NotesManager('test_notes.json');
+    // Clean up previous test
+    try {
+        await fs.unlink('test_notes.json');
+    }
+    catch { }
+    console.log("1. Adding CRITICAL note (expires tomorrow)...");
+    await notes.addNote("Urgent Security Fix", "Fix the login bug", ["bug"], "critical", new Date(Date.now() + 86400000).toISOString());
+    console.log("2. Adding LOW priority note...");
+    await notes.addNote("Refactor UI", "Make it pretty eventually", ["ui"], "low");
+    console.log("3. Listing notes (Expect Critical first)...");
+    const list = await notes.listNotes();
+    list.forEach(n => console.log(`- [${n.priority.toUpperCase()}] ${n.title}`));
+    // --- 2. Testing Code Database ---
+    console.log("\n--- Testing Code Database ---");
+    const codeDb = new CodeDatabase('test_code_db.json');
+    try {
+        await fs.unlink('test_code_db.json');
+    }
+    catch { }
+    console.log("1. Adding Code Snippet...");
+    await codeDb.addSnippet({
+        title: "Deepest Thinking Prompt",
+        language: "markdown",
+        code: "You must use sequentialthinking...",
+        description: "Standard prompt for deep agents",
+        tags: ["prompt", "ai"]
+    });
+    console.log("2. Searching for 'Deepest'...");
+    const results = await codeDb.searchSnippets("Deepest");
+    console.log(`Found ${results.length} result(s):`);
+    results.forEach(r => console.log(`- ${r.title} (${r.language})`));
+    console.log("\n✅ Test Complete!");
+    // Cleanup
+    try {
+        await fs.unlink('test_notes.json');
+    }
+    catch { }
+    try {
+        await fs.unlink('test_code_db.json');
+    }
+    catch { }
+}
+testSystem();

package/dist/tools/codestore.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export function registerCodeDbTools(server, db) {
+    // 16. add_code_snippet
+    server.tool("add_code_snippet", "Add a useful code snippet or implementation pattern to the persistent Code Database.", {
+        title: z.string().describe("Title of the snippet"),
+        code: z.string().describe("The actual code"),
+        language: z.string().describe("Programming language"),
+        description: z.string().describe("What this code does and why it is useful"),
+        tags: z.array(z.string()).optional().default([]).describe("Tags for categorization")
+    }, async (args) => {
+        const snippet = await db.addSnippet(args);
+        return {
+            content: [{ type: "text", text: `Snippet saved with ID: ${snippet.id}` }]
+        };
+    });
+    // 17. search_code_db
+    server.tool("search_code_db", "Search the Code Database for existing snippets, patterns, or architectural knowledge.", {
+        query: z.string().describe("Search query")
+    }, async ({ query }) => {
+        const results = await db.searchSnippets(query);
+        const patterns = await db.listAllPatterns();
+        let output = `--- CODE DATABASE RESULTS ---\n\n`;
+        if (results.length > 0) {
+            output += `SNIPPETS FOUND:\n`;
+            results.forEach(s => {
+                output += `ID: ${s.id} | ${s.title} (${s.language})\nDesc: ${s.description}\nCode:\n\`\`\`\n${s.code}\n\`\`\`\n\n`;
+            });
+        }
+        const matchedPatterns = Object.entries(patterns).filter(([k, v]) => k.toLowerCase().includes(query.toLowerCase()) || v.toLowerCase().includes(query.toLowerCase()));
+        if (matchedPatterns.length > 0) {
+            output += `PATTERNS FOUND:\n`;
+            matchedPatterns.forEach(([name, desc]) => {
+                output += `- ${name}: ${desc}\n`;
+            });
+        }
+        if (results.length === 0 && matchedPatterns.length === 0) {
+            output += "No results found in the Code Database.";
+        }
+        return { content: [{ type: "text", text: output }] };
+    });
+    // 18. learn_architecture_pattern
+    server.tool("learn_architecture_pattern", "Store a high-level architectural or logic pattern in the Code DB (e.g., 'auth-flow', 'error-handling-strategy').", {
+        name: z.string().describe("Name of the pattern"),
+        description: z.string().describe("Detailed description of the pattern and how it applies to this project")
+    }, async ({ name, description }) => {
+        await db.learnPattern(name, description);
+        return {
+            content: [{ type: "text", text: `Pattern '${name}' learned and stored.` }]
+        };
+    });
+}

package/dist/tools/notes.js

@@ -1,24 +1,27 @@
 import { z } from "zod";
 export function registerNoteTools(server, notesManager) {
     // 15. manage_notes
-    server.tool("manage_notes", "Manage long-term memory/notes. Use this to save important information, rules, or learnings that should persist across sessions.", {
+    server.tool("manage_notes", "Manage long-term memory/notes. Use this to save important information, rules, or learnings that should persist across sessions. Supports priority levels and expiration dates.", {
         action: z.enum(['add', 'list', 'search', 'update', 'delete']).describe("Action to perform"),
         title: z.string().optional().describe("Title of the note (for add/update)"),
         content: z.string().optional().describe("Content of the note (for add/update)"),
         tags: z.array(z.string()).optional().describe("Tags for categorization (for add/update)"),
         searchQuery: z.string().optional().describe("Query to search notes (for search)"),
-        noteId: z.string().optional().describe("ID of the note (for update/delete)")
-    }, async ({ action, title, content, tags, searchQuery, noteId }) => {
+        noteId: z.string().optional().describe("ID of the note (for update/delete)"),
+        priority: z.enum(['low', 'medium', 'high', 'critical']).optional().default('medium').describe("Priority level"),
+        expiresAt: z.string().optional().describe("Expiration date in ISO format (e.g., 2026-12-31)"),
+        includeExpired: z.boolean().optional().default(false).describe("Whether to include expired notes in list")
+    }, async ({ action, title, content, tags, searchQuery, noteId, priority, expiresAt, includeExpired }) => {
         try {
             switch (action) {
                 case 'add':
                     if (!title || !content) {
                         return { content: [{ type: "text", text: "Error: 'title' and 'content' are required for add action." }], isError: true };
                     }
-                    const newNote = await notesManager.addNote(title, content, tags);
-                    return { content: [{ type: "text", text: `Note added successfully.\nID: ${newNote.id}` }] };
+                    const newNote = await notesManager.addNote(title, content, tags, priority, expiresAt);
+                    return { content: [{ type: "text", text: `Note added successfully.\nID: ${newNote.id} (Priority: ${newNote.priority})` }] };
                 case 'list':
-                    const notes = await notesManager.listNotes();
+                    const notes = await notesManager.listNotes(undefined, includeExpired);
                     return { content: [{ type: "text", text: JSON.stringify(notes, null, 2) }] };
                 case 'search':
                     if (!searchQuery) {

package/dist/tools/thinking.js

@@ -27,6 +27,13 @@ Key features:
 - Hypothesis Testing: Formulate and verify hypotheses based on Chain of Thought.
 - Branch Merging: Combine insights from multiple divergent paths.
 
+Troubleshooting & Stuck States:
+- If you realize you are stuck in a loop or a bug persists after 2 attempts:
+  1. Do NOT continue linear thoughts.
+  2. Create a NEW BRANCH ('branchFromThought') from a point before the error.
+  3. Explicitly state "Stuck detected, branching to explore Approach B".
+  4. Change your fundamental assumptions or implementation strategy completely.
+
 Parameters explained:
 - thought: Your current thinking step (analysis, revision, question, hypothesis).
 - nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end.

package/package.json

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