@gotza02/sequential-thinking 2026.3.9 → 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/package.json

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