@gotza02/sequential-thinking 2026.3.9 → 2026.3.11

package/dist/core/ContextManager.d.ts

@@ -0,0 +1,9 @@
+import { ThoughtData } from '../lib.js';
+export declare class ContextManager {
+    private summaryCache;
+    constructor();
+    getOptimizedContext(history: ThoughtData[], currentBlockId: string | null): Promise<string>;
+    private compressOldBlocks;
+    private groupByBlock;
+    private generateSummary;
+}

package/dist/core/ContextManager.js

@@ -0,0 +1,62 @@
+export class ContextManager {
+    summaryCache = new Map();
+    constructor() { }
+    async getOptimizedContext(history, currentBlockId) {
+        // If no current block, treat everything as old or just show all?
+        // If null, we might be in setup mode. Let's assume empty current block.
+        const safeCurrentBlockId = currentBlockId || '';
+        const oldBlocks = history.filter(t => t.blockId !== safeCurrentBlockId);
+        const activeBlock = history.filter(t => t.blockId === safeCurrentBlockId);
+        const summaries = await this.compressOldBlocks(oldBlocks);
+        // Format active block detailed
+        const activeContext = activeBlock.map(t => `[${t.thoughtType?.toUpperCase() || 'INFO'}] #${t.thoughtNumber}: ${t.thought}`).join('\n');
+        return `
+=== PROJECT HISTORY (SUMMARIZED) ===
+${summaries}
+
+=== CURRENT FOCUS (DETAILED: ${safeCurrentBlockId || 'GLOBAL'}) ===
+${activeContext}
+`;
+    }
+    async compressOldBlocks(logs) {
+        const groups = this.groupByBlock(logs);
+        let result = '';
+        for (const [blockId, thoughts] of groups) {
+            // Skip blocks with undefined or empty blockId if they sneak in
+            if (!blockId)
+                continue;
+            const cached = this.summaryCache.get(blockId);
+            if (cached && cached.count === thoughts.length) {
+                result += `[Block: ${blockId}] Summary: ${cached.summary}\n`;
+            }
+            else {
+                if (thoughts.length > 2) {
+                    const summary = await this.generateSummary(thoughts);
+                    this.summaryCache.set(blockId, { summary, count: thoughts.length });
+                    result += `[Block: ${blockId}] Summary: ${summary}\n`;
+                }
+                else {
+                    result += `[Block: ${blockId}] ${thoughts.map(t => t.thought).join(' -> ')}\n`;
+                }
+            }
+        }
+        return result;
+    }
+    groupByBlock(logs) {
+        const map = new Map();
+        logs.forEach(log => {
+            const bid = log.blockId || 'default';
+            const items = map.get(bid) || [];
+            items.push(log);
+            map.set(bid, items);
+        });
+        return map;
+    }
+    async generateSummary(thoughts) {
+        // Mock implementation
+        const decisions = thoughts.filter(t => t.thoughtType === 'planning' || t.thoughtType === 'selection').length;
+        const executions = thoughts.filter(t => t.thoughtType === 'execution').length;
+        const topic = thoughts[0]?.thought.substring(0, 30) || 'Unknown';
+        return `Topic: "${topic}...". Processed ${thoughts.length} steps (${decisions} plans, ${executions} actions). Outcome: Handed off or completed.`;
+    }
+}

package/dist/lib.d.ts

@@ -38,6 +38,7 @@ export declare class SequentialThinkingServer {
     private saveMutex;
     private consecutiveStallCount;
     private confidenceScore;
+    private contextManager;
     constructor(storagePath?: string, delayMs?: number);
     private loadHistory;
     private attemptRecovery;

package/dist/lib.js

@@ -3,6 +3,7 @@ import * as fs from 'fs/promises';
 import { existsSync, readFileSync } from 'fs';
 import * as path from 'path';
 import { AsyncMutex } from './utils.js';
+import { ContextManager } from './core/ContextManager.js';
 export class SequentialThinkingServer {
     thoughtHistory = [];
     blocks = [];
@@ -15,6 +16,7 @@ export class SequentialThinkingServer {
     saveMutex = new AsyncMutex();
     consecutiveStallCount = 0; // Track consecutive stalls/loops
     confidenceScore = 100; // Meta-Cognition Score (0-100)
+    contextManager = new ContextManager();
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -437,6 +439,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 < 75) {
+                    this.confidenceScore = 75;
+                    feedbackExtension += `\n🌿 BRANCH DETECTED: Confidence restored to 75. Good decision to pivot.`;
+                }
+            }
             // --- 🧠 FEATURE 1: Semantic Thought Recall ---
             if (input.thoughtType === 'analysis') {
                 const previousSolution = await this.findSolution(input.thought);
@@ -444,14 +453,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 +568,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)
@@ -637,6 +683,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             // D. Generate Contextual Output
             const currentBlock = this.blocks.find(b => b.id === input.blockId);
             const mermaid = this.generateMermaid();
+            const optimizedContext = await this.contextManager.getOptimizedContext(this.thoughtHistory, input.blockId || null);
             if (feedbackExtension)
                 warnings.push(feedbackExtension);
             return {
@@ -650,6 +697,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                             blockContext: currentBlock
                                 ? `Block '${currentBlock.topic.substring(0, 30)}' has ${currentBlock.thoughts.length} thoughts.`
                                 : 'No active block',
+                            optimizedContext,
                             branches: Object.keys(this.branches),
                             thoughtHistoryLength: this.thoughtHistory.length,
                             feedback: warnings.length > 0 ? warnings : "Flow Healthy ✅",

package/package.json

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