@gotza02/sequential-thinking 10000.1.7 → 10000.1.8

package/dist/lib.js

@@ -20,7 +20,14 @@ export class SequentialThinkingServer {
     contextManager = new ContextManager();
     ruleManager = new RuleManager();
     maxHistorySize;
-    constructor(storagePath = 'thoughts_history.json', delayMs = 0, maxHistorySize = 1000) {
+    // Constants for configuration
+    static MAX_HISTORY_SIZE = 1000;
+    static AUTO_PRUNE_THRESHOLD = 100;
+    static CONFIDENCE_CRITICAL_THRESHOLD = 50;
+    static MAX_NESTING_DEPTH = 10;
+    static STALLING_THRESHOLD = 3;
+    static EXECUTION_STRUGGLE_THRESHOLD = 3;
+    constructor(storagePath = 'thoughts_history.json', delayMs = 0, maxHistorySize = SequentialThinkingServer.MAX_HISTORY_SIZE) {
         this.maxHistorySize = maxHistorySize;
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -190,8 +197,8 @@ export class SequentialThinkingServer {
     async saveHistory() {
         await this.saveMutex.dispatch(async () => {
             try {
-                // Auto-Pruning: Keep max 100 thoughts, summarize older blocks
-                if (this.thoughtHistory.length > 100) {
+                // Auto-Pruning: Keep max thoughts within threshold
+                if (this.thoughtHistory.length > SequentialThinkingServer.AUTO_PRUNE_THRESHOLD) {
                     try {
                         this.autoPrune();
                     }
@@ -270,9 +277,9 @@ export class SequentialThinkingServer {
                 this.blocks[i].status = 'completed';
             }
         }
-        // Keep only last 100 thoughts
-        if (this.thoughtHistory.length > 100) {
-            const removed = this.thoughtHistory.splice(0, this.thoughtHistory.length - 100);
+        // Keep only last N thoughts based on threshold
+        if (this.thoughtHistory.length > SequentialThinkingServer.AUTO_PRUNE_THRESHOLD) {
+            const removed = this.thoughtHistory.splice(0, this.thoughtHistory.length - SequentialThinkingServer.AUTO_PRUNE_THRESHOLD);
             console.error(`[AutoPrune] Removed ${removed.length} old thoughts to maintain performance.`);
             // Sync blocks: Remove pruned thoughts from their respective blocks
             // This prevents unbounded file growth by ensuring blocks don't retain references to deleted thoughts
@@ -457,6 +464,281 @@ export class SequentialThinkingServer {
 ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrappedThought : `│ ${thought.padEnd(borderLength - 2)} │`}${extraContent}
 └${border}┘`;
     }
+    // --- Extracted Helper Methods for processThought ---
+    /**
+     * Handle block management - create new blocks or switch context
+     */
+    async handleBlockManagement(input, warnings) {
+        if (!input.blockId) {
+            if (!this.currentBlockId) {
+                this.currentBlockId = `block-${Date.now()}`;
+                this.blocks.push({
+                    id: this.currentBlockId,
+                    topic: input.thought.substring(0, 50),
+                    status: 'active',
+                    thoughts: [],
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                });
+            }
+            input.blockId = this.currentBlockId;
+        }
+        else if (input.blockId !== this.currentBlockId) {
+            // Context switch detected
+            const oldBlock = this.blocks.find(b => b.id === this.currentBlockId);
+            if (oldBlock) {
+                oldBlock.status = 'completed';
+                await this.learnFromFailures(oldBlock.id);
+                // 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);
+            if (!existingBlock) {
+                this.blocks.push({
+                    id: input.blockId,
+                    topic: input.thought.substring(0, 50),
+                    status: 'active',
+                    thoughts: [],
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                });
+            }
+            else {
+                existingBlock.status = 'active';
+            }
+        }
+    }
+    /**
+     * Detect loops, stalling, and other thinking pattern issues
+     */
+    detectLoopsAndStalling(input, blockThoughts, recentInBlock, lastThought, complexity) {
+        const warnings = [];
+        let isStallingOrLooping = false;
+        const thinkingTypes = ['analysis', 'planning', 'hypothesis', 'generation', 'critique'];
+        // Rule 1: Stalling Detection (Adaptive)
+        if (complexity !== 'low') {
+            if (recentInBlock.length >= SequentialThinkingServer.STALLING_THRESHOLD &&
+                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') {
+            // Check Immune System Rules
+            const ruleWarnings = this.ruleManager.checkRules(input.thought);
+            ruleWarnings.forEach(w => warnings.push(w));
+            if (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
+        if (lastThought &&
+            lastThought.thoughtType === 'execution' &&
+            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)
+        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.`);
+            }
+        }
+        // Rule 5: 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.`);
+            }
+        }
+        // Rule 6: Ending without Verification
+        if (input.nextThoughtNeeded === false) {
+            const hasVerification = this.thoughtHistory.some(t => t.thought.toLowerCase().includes('test') ||
+                t.thought.toLowerCase().includes('verify') ||
+                t.thought.toLowerCase().includes('check') ||
+                t.thoughtType === 'observation');
+            if (!hasVerification) {
+                warnings.push(`🚨 CRITICAL: You are ending without explicit verification/testing. Consider adding an 'observation' or verification step.`);
+            }
+        }
+        // Rule 7: Same type loop
+        if (complexity !== 'low' && recentInBlock.length >= SequentialThinkingServer.STALLING_THRESHOLD &&
+            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 8: Struggle Detection
+        const executionCount = blockThoughts.filter(t => t.thoughtType === 'execution').length;
+        if (executionCount >= SequentialThinkingServer.EXECUTION_STRUGGLE_THRESHOLD && input.thoughtType === 'execution') {
+            warnings.push(`🛑 STRUGGLE DETECTED: You have executed ${SequentialThinkingServer.EXECUTION_STRUGGLE_THRESHOLD}+ 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 9: Premature Solution Detection
+        const hasObservation = blockThoughts.some(t => t.thoughtType === 'observation');
+        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.`);
+        }
+        return { isStallingOrLooping, warnings };
+    }
+    /**
+     * Validate solution before accepting
+     */
+    async validateSolution(input, blockThoughts, complexity, warnings) {
+        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.`);
+        }
+        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)}..."). 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?`);
+            }
+            // 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;
+            }
+        }
+        // Save solution if no warnings
+        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.learnFromFailures(input.blockId || "");
+            await this.saveSolution(activeBlock?.topic || 'Untitled', input.thought, solutionSteps);
+        }
+    }
+    /**
+     * Update confidence score based on thought type and warnings
+     */
+    updateConfidenceScore(input, warnings) {
+        if (warnings.length > 0) {
+            this.confidenceScore = Math.max(0, this.confidenceScore - (5 * warnings.length));
+        }
+        if (input.thoughtType === 'reflexion') {
+            this.confidenceScore = Math.min(100, this.confidenceScore + 10);
+        }
+        else if (input.thoughtType === 'observation') {
+            const isError = input.toolResult?.toLowerCase().includes('error');
+            if (isError)
+                this.confidenceScore -= 10;
+            else
+                this.confidenceScore = Math.min(100, this.confidenceScore + 10);
+        }
+        else if (input.thoughtType === 'solution' && warnings.length === 0) {
+            // Bonus for clean solution
+            this.confidenceScore = Math.min(100, this.confidenceScore + 20);
+        }
+    }
+    // --- Helper Methods for processThought ---
+    /**
+     * Get block history for current input
+     */
+    getBlockHistory(input) {
+        return this.thoughtHistory.filter(t => t.blockId === input.blockId ||
+            (input.blockId === this.currentBlockId && t.blockId === this.currentBlockId));
+    }
+    /**
+     * Check for smart branching - reset confidence on pivot
+     */
+    checkSmartBranching(input) {
+        if (input.branchFromThought && this.confidenceScore < 75) {
+            this.confidenceScore = 75;
+            return `\n🌿 BRANCH DETECTED: Confidence restored to 75. Good decision to pivot.`;
+        }
+        return "";
+    }
+    /**
+     * Check semantic thought recall for analysis type
+     */
+    async checkSemanticRecall(input) {
+        if (input.thoughtType === 'analysis') {
+            const previousSolution = await this.findSolution(input.thought);
+            if (previousSolution) {
+                return `\n💡 RECALL: I found a similar past solution for '${previousSolution.topic}'.\nTry these steps: ${previousSolution.solution.substring(0, 100)}...`;
+            }
+        }
+        return "";
+    }
+    /**
+     * Check anti-insanity - prevent repeating failed executions
+     */
+    checkAntiInsanity(input, historyForCheck) {
+        const warnings = [];
+        if (input.thoughtType === 'execution') {
+            const failedExecutions = historyForCheck.filter(t => {
+                if (t.thoughtType !== 'execution')
+                    return false;
+                // Find the observation immediately following this execution
+                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;
+            }
+        }
+        return warnings;
+    }
+    /**
+     * Check if confidence is critical and return critical stop response if needed
+     */
+    checkConfidenceCritical(input, historyForCheck) {
+        if (this.confidenceScore >= SequentialThinkingServer.CONFIDENCE_CRITICAL_THRESHOLD ||
+            input.thoughtType === 'reflexion' ||
+            input.thoughtType === 'analysis') {
+            return null;
+        }
+        // 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 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.",
+                            "⚠️ REMEMBER: You MUST provide a 'thought' string explaining your reflection. Do not leave it empty.",
+                            recoveryAdvice
+                        ],
+                        confidenceScore: this.confidenceScore
+                    }, null, 2)
+                }],
+            isError: true
+        };
+    }
     // --- 2. The New Brain: Process Thought with Interleaved Logic (Opus 4.5 Style) ---
     async processThought(input) {
         try {
@@ -466,226 +748,31 @@ ${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 0: Smart Branching Reward ---
+            feedbackExtension += this.checkSmartBranching(input);
             // --- 🧠 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 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 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.",
-                                    "⚠️ REMEMBER: You MUST provide a 'thought' string explaining your reflection. Do not leave it empty.",
-                                    recoveryAdvice
-                                ],
-                                confidenceScore: this.confidenceScore
-                            }, null, 2)
-                        }],
-                    isError: true
-                };
-            }
+            feedbackExtension += await this.checkSemanticRecall(input);
+            // --- ⛔ FEATURE 1.5: Anti-Insanity Check ---
+            const historyForCheck = this.getBlockHistory(input);
+            warnings.push(...this.checkAntiInsanity(input, historyForCheck));
+            // --- 📊 FEATURE 4: Meta-Cognition Score Check ---
+            const criticalResult = this.checkConfidenceCritical(input, historyForCheck);
+            if (criticalResult)
+                return criticalResult;
             // A. Block Management (Auto-Create Block)
-            if (!input.blockId) {
-                if (!this.currentBlockId) {
-                    this.currentBlockId = `block-${Date.now()}`;
-                    this.blocks.push({
-                        id: this.currentBlockId,
-                        topic: input.thought.substring(0, 50),
-                        status: 'active',
-                        thoughts: [],
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString()
-                    });
-                }
-                input.blockId = this.currentBlockId;
-            }
-            else if (input.blockId !== this.currentBlockId) {
-                // Context switch detected
-                const oldBlock = this.blocks.find(b => b.id === this.currentBlockId);
-                if (oldBlock) {
-                    oldBlock.status = 'completed';
-                    await this.learnFromFailures(oldBlock.id);
-                    // 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);
-                if (!existingBlock) {
-                    this.blocks.push({
-                        id: input.blockId,
-                        topic: input.thought.substring(0, 50),
-                        status: 'active',
-                        thoughts: [],
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString()
-                    });
-                }
-                else {
-                    existingBlock.status = 'active';
-                }
-            }
+            await this.handleBlockManagement(input, warnings);
             // B. Smart Loop Detection (Opus Style)
             const blockThoughts = this.thoughtHistory.filter(t => t.blockId === input.blockId);
-            const recentInBlock = blockThoughts.slice(-3);
+            const recentInBlock = blockThoughts.slice(-SequentialThinkingServer.STALLING_THRESHOLD);
             const lastThought = this.thoughtHistory[this.thoughtHistory.length - 1];
-            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') {
-                // Check Immune System Rules
-                const ruleWarnings = this.ruleManager.checkRules(input.thought);
-                ruleWarnings.forEach(w => warnings.push(w));
-                if (ruleWarnings.length > 0)
-                    this.confidenceScore -= 10;
-                if (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
-            if (lastThought &&
-                lastThought.thoughtType === 'execution' &&
-                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)
-            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) {
-                const hasVerification = this.thoughtHistory.some(t => t.thought.toLowerCase().includes('test') ||
-                    t.thought.toLowerCase().includes('verify') ||
-                    t.thought.toLowerCase().includes('check') ||
-                    t.thoughtType === 'observation');
-                if (!hasVerification) {
-                    warnings.push(`🚨 CRITICAL: You are ending without explicit verification/testing. Consider adding an 'observation' or verification step.`);
-                }
-            }
-            // 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
-            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
-            const hasObservation = blockThoughts.some(t => t.thoughtType === 'observation');
-            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 10: Mandatory Verification (Gatekeeper) & Double Verification
+            const loopDetection = this.detectLoopsAndStalling(input, blockThoughts, recentInBlock, lastThought, complexity);
+            warnings.push(...loopDetection.warnings);
+            let isStallingOrLooping = loopDetection.isStallingOrLooping;
+            // C. Validate Solution
             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.`);
-                }
-                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)}..."). 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.learnFromFailures(input.blockId || "");
-                    await this.saveSolution(activeBlock?.topic || 'Untitled', input.thought, solutionSteps);
-                }
+                await this.validateSolution(input, blockThoughts, complexity, warnings);
             }
-            // Human Escalation Trigger
+            // D. Human Escalation Trigger
             if (isStallingOrLooping) {
                 this.consecutiveStallCount++;
                 if (this.consecutiveStallCount >= 2) {
@@ -695,24 +782,8 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
             else {
                 this.consecutiveStallCount = 0;
             }
-            // --- 📊 Update Confidence Score ---
-            if (warnings.length > 0) {
-                this.confidenceScore = Math.max(0, this.confidenceScore - (5 * warnings.length));
-            }
-            if (input.thoughtType === 'reflexion') {
-                this.confidenceScore = Math.min(100, this.confidenceScore + 10);
-            }
-            else if (input.thoughtType === 'observation') {
-                const isError = input.toolResult?.toLowerCase().includes('error');
-                if (isError)
-                    this.confidenceScore -= 10;
-                else
-                    this.confidenceScore = Math.min(100, this.confidenceScore + 10);
-            }
-            else if (input.thoughtType === 'solution' && warnings.length === 0) {
-                // Bonus for clean solution
-                this.confidenceScore = Math.min(100, this.confidenceScore + 20);
-            }
+            // E. Update Confidence Score
+            this.updateConfidenceScore(input, warnings);
             // C. Update State
             this.addToMemory(input);
             await this.saveHistory();

package/dist/parsers/GenericParser.d.ts

@@ -0,0 +1,6 @@
+import { ParseResult } from './TypeScriptParser.js';
+export declare class GenericParser {
+    parse(filePath: string): Promise<ParseResult>;
+}
+export declare const genericParser: GenericParser;
+export default genericParser;

package/dist/parsers/GenericParser.js

@@ -0,0 +1,52 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class GenericParser {
+    async parse(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            const ext = path.extname(filePath);
+            // C/C++
+            if (['.c', '.cpp', '.h', '.hpp', '.cc', '.cxx'].includes(ext)) {
+                const includeMatches = content.matchAll(/#include\s*[<"]([^>"]+)[>"]/g);
+                for (const match of includeMatches)
+                    imports.push(match[1]);
+                const funcMatches = content.matchAll(/^\w[\w\s*]+\s+(\w+)\s*\([^)]*\)\s*{/gm);
+                for (const match of funcMatches)
+                    symbols.push(`function:${match[1]}`);
+            }
+            // Ruby
+            else if (ext === '.rb') {
+                const requireMatches = content.matchAll(/require\s+['"]([^'"]+)['"]/g);
+                for (const match of requireMatches)
+                    imports.push(match[1]);
+                const defMatches = content.matchAll(/^def\s+([a-z_][a-z0-9_!?]*)/gm);
+                for (const match of defMatches)
+                    symbols.push(`def:${match[1]}`);
+                const classMatches = content.matchAll(/^class\s+([A-Z][A-Za-z0-9_]*)/gm);
+                for (const match of classMatches)
+                    symbols.push(`class:${match[1]}`);
+            }
+            // PHP
+            else if (ext === '.php') {
+                const useMatches = content.matchAll(/^use\s+([^;]+);/gm);
+                for (const match of useMatches)
+                    imports.push(match[1].trim());
+                const funcMatches = content.matchAll(/^function\s+([a-z_][a-z0-9_]*)/gm);
+                for (const match of funcMatches)
+                    symbols.push(`function:${match[1]}`);
+                const classMatches = content.matchAll(/^class\s+([A-Z][A-Za-z0-9_]*)/gm);
+                for (const match of classMatches)
+                    symbols.push(`class:${match[1]}`);
+            }
+            return { imports, symbols };
+        }
+        catch (error) {
+            console.error(`Error parsing generic file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
+        }
+    }
+}
+export const genericParser = new GenericParser();
+export default genericParser;