@gotza02/sequential-thinking 2026.3.8 → 2026.3.10

package/dist/lib.js

@@ -437,6 +437,13 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             const complexity = input.complexity || 'medium';
             const warnings = [];
             let feedbackExtension = "";
+            // --- 🔄 FEATURE 0: Smart Branching Reward (Reset Confidence on Pivot) ---
+            if (input.branchFromThought) {
+                if (this.confidenceScore < 90) {
+                    this.confidenceScore = 90;
+                    feedbackExtension += `\n🌿 BRANCH DETECTED: Confidence restored to 90. Good decision to pivot.`;
+                }
+            }
             // --- 🧠 FEATURE 1: Semantic Thought Recall ---
             if (input.thoughtType === 'analysis') {
                 const previousSolution = await this.findSolution(input.thought);
@@ -444,14 +451,50 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                     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 ---
+            // --- ⛔ FEATURE 1.5: Anti-Insanity (Prevent Repeating Failed Executions) ---
+            const historyForCheck = this.thoughtHistory.filter(t => t.blockId === input.blockId || (input.blockId === this.currentBlockId && t.blockId === this.currentBlockId));
+            if (input.thoughtType === 'execution') {
+                const failedExecutions = historyForCheck.filter((t, index) => {
+                    if (t.thoughtType !== 'execution')
+                        return false;
+                    // Find the observation immediately following this execution
+                    // Note: This relies on thoughtNumber order
+                    const nextThought = this.thoughtHistory.find(h => h.thoughtNumber === t.thoughtNumber + 1);
+                    if (nextThought && nextThought.thoughtType === 'observation') {
+                        const result = nextThought.toolResult?.toLowerCase() || "";
+                        // Check for failure signals
+                        return result.includes("error") || result.includes("fail") || result.includes("exception") || result.includes("enoent");
+                    }
+                    return false;
+                });
+                const isRepeatedFailure = failedExecutions.some(t => t.thought.trim() === input.thought.trim());
+                if (isRepeatedFailure) {
+                    const failedItem = failedExecutions.find(t => t.thought.trim() === input.thought.trim());
+                    warnings.push(`⛔ INSANITY CHECK: You are trying to run a command that ALREADY FAILED in thought #${failedItem?.thoughtNumber}. STOP. Do not repeat mistakes. Try a different parameter or tool.`);
+                    this.confidenceScore -= 15;
+                }
+            }
+            // --- 📊 FEATURE 4: Meta-Cognition Score Check (Reflexion Mandate & Smart Branching) ---
             if (this.confidenceScore < 50 && input.thoughtType !== 'reflexion' && input.thoughtType !== 'analysis') {
+                // Smart Branching: Find the last valid planning point
+                const lastGoodPlan = historyForCheck
+                    .slice()
+                    .reverse()
+                    .find(t => t.thoughtType === 'planning' || t.thoughtType === 'hypothesis');
+                const recoveryAdvice = lastGoodPlan
+                    ? `RECOMMENDATION: Branch from thought #${lastGoodPlan.thoughtNumber} to try a new approach.`
+                    : `RECOMMENDATION: Use 'reflexion' to analyze why current attempts are failing.`;
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 status: "CRITICAL_STOP",
-                                feedback: ["🚨 CONFIDENCE TOO LOW (<50). Execution blocked. Please use 'reflexion' or 'analysis' to self-correct, or request human intervention."],
+                                feedback: [
+                                    "🚨 CONFIDENCE CRITICAL (<50). Execution blocked to prevent further damage.",
+                                    "🛑 STOP: You are likely in a loop or making repeated errors.",
+                                    "👉 REQUIRED ACTION: You must switch thoughtType to 'reflexion' to critique your errors.",
+                                    recoveryAdvice
+                                ],
                                 confidenceScore: this.confidenceScore
                             }, null, 2)
                         }],
@@ -523,7 +566,8 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             // Rule 3: Missing Observation
             if (lastThought &&
                 lastThought.thoughtType === 'execution' &&
-                input.thoughtType !== 'observation') {
+                input.thoughtType !== 'observation' &&
+                !input.branchFromThought) {
                 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 (Adaptive)

package/dist/tools/thinking.js

@@ -87,21 +87,8 @@ 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.preprocess((val) => {
-            if (typeof val !== 'string')
-                return val;
-            const v = val.toLowerCase();
-            if (['simple', 'easy', 'basic'].includes(v))
-                return 'low';
-            if (['standard', 'normal', 'regular'].includes(v))
-                return 'medium';
-            if (['critical', 'expert', 'very high'].includes(v))
-                return 'high';
-            // If it's a string but not one of the enum values, default to medium
-            if (!['low', 'medium', 'high'].includes(v))
-                return 'medium';
-            return v;
-        }, z.enum(['low', 'medium', 'high']).optional()).describe("Task complexity level. 'low': simple tasks, less strict. 'medium': standard. 'high': critical, requires critique & double verification."),
+        complexity: z.string().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"),
@@ -114,14 +101,30 @@ If you have tried to fix the same problem 3 times and failed:
     }, async (args) => {
         try {
             const thoughtNumber = args.thoughtNumber ?? (thinkingServer.getHistoryLength() + 1);
+            // Normalize complexity manually since we removed z.preprocess to avoid schema validation errors
+            let complexity = 'medium';
+            if (args.complexity) {
+                const v = args.complexity.toLowerCase();
+                if (['low', 'simple', 'easy', 'basic'].includes(v))
+                    complexity = 'low';
+                else if (['high', 'critical', 'expert', 'very high'].includes(v))
+                    complexity = 'high';
+                else
+                    complexity = 'medium';
+            }
             // Smart defaults for totalThoughts based on complexity
             let defaultAdd = 5;
-            if (args.complexity === 'low')
+            if (complexity === 'low')
                 defaultAdd = 3;
-            else if (args.complexity === 'high')
+            else if (complexity === 'high')
                 defaultAdd = 8;
             const totalThoughts = args.totalThoughts ?? (thoughtNumber + defaultAdd);
-            const input = { ...args, thoughtNumber, totalThoughts };
+            const input = {
+                ...args,
+                thoughtNumber,
+                totalThoughts,
+                complexity: complexity
+            };
             const result = await thinkingServer.processThought(input);
             return {
                 content: result.content,

package/package.json

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