@gotza02/mathinking 2.9.3 → 2.9.5

package/dist/tools/sequential-thinking.js

@@ -2,266 +2,178 @@ import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as os from 'os';
+import { LRUCache } from 'lru-cache';
+import { Mutex } from '../utils/mutex.js';
 import { orchestratorManager } from './orchestrator.js';
-/**
- * Sequential Thinking Manager (The Brain)
- */
+import { vectorMemory } from '../utils/vector-memory.js';
+import { BrainInputSchema } from '../schemas/brain.schema.js';
 export class SequentialThinkingManager {
-    sessions = new Map();
+    sessions = new LRUCache({
+        max: 100,
+        ttl: 1000 * 60 * 60 * 24 // 24 hours
+    });
     lastSessionId = null;
     storagePath;
     initialized = false;
     lastActionTimestamp = 0;
-    MIN_DELAY_MS = 800; // Minimum delay between actions to prevent flooding
+    MIN_DELAY_MS = 500;
+    mutex = new Mutex();
     constructor() {
-        // Set up persistent storage in user's home directory
         this.storagePath = path.join(os.homedir(), '.mathinking', 'sessions.json');
     }
-    /**
-     * Helper to add a delay
-     */
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    /**
-     * Initialize storage directory and load existing sessions
-     */
-    async initStorage(force = false) {
+    async _initStorage(force = false) {
         if (this.initialized && !force)
             return;
         try {
             const dir = path.dirname(this.storagePath);
             await fs.mkdir(dir, { recursive: true });
             const data = await fs.readFile(this.storagePath, 'utf8');
-            let savedSessions;
-            try {
-                savedSessions = JSON.parse(data);
-            }
-            catch (parseError) {
-                if (!this.initialized) {
-                    console.warn('[Brain] Storage file is invalid or empty, initializing with empty sessions.');
-                }
-                savedSessions = {};
-            }
-            // Merge or replace sessions
-            let newestTimestamp = 0;
+            const savedSessions = JSON.parse(data);
             for (const [id, session] of Object.entries(savedSessions)) {
                 this.sessions.set(id, session);
-                // Track the truly latest session by updatedAt
-                const ts = new Date(session.updatedAt).getTime();
-                if (ts > newestTimestamp) {
-                    newestTimestamp = ts;
-                    this.lastSessionId = id;
-                }
-            }
-            if (!this.initialized) {
-                console.error(`[Brain] Loaded ${this.sessions.size} sessions from storage.`);
+                this.lastSessionId = id;
             }
         }
         catch (error) {
-            // If file doesn't exist or is invalid, start with empty map
-            if (error.code !== 'ENOENT') {
-                console.error('[Brain] Storage initialization error:', error);
-            }
+            // Ignore error if file doesn't exist
         }
         finally {
             this.initialized = true;
         }
     }
-    /**
-     * Save all sessions to persistent storage
-     */
-    async saveToStorage() {
+    async initStorage(force = false) {
+        await this.mutex.dispatch(() => this._initStorage(force));
+    }
+    async _saveToStorage() {
         try {
-            // Auto-pruning: Keep only the 100 most recent sessions
-            if (this.sessions.size > 100) {
-                const sortedSessions = Array.from(this.sessions.entries()).sort((a, b) => new Date(b[1].updatedAt).getTime() - new Date(a[1].updatedAt).getTime());
-                const toKeep = sortedSessions.slice(0, 100);
-                this.sessions = new Map(toKeep);
-                console.error(`[Brain] Pruned sessions. Kept the 100 most recent.`);
+            const entries = {};
+            for (const [key, value] of this.sessions.entries()) {
+                entries[key] = value;
             }
-            const data = JSON.stringify(Object.fromEntries(this.sessions), null, 2);
+            const data = JSON.stringify(entries, null, 2);
             await fs.writeFile(this.storagePath, data, 'utf8');
         }
         catch (error) {
-            console.error('[Brain] Failed to save sessions:', error);
+            console.error('[Brain] Save failed:', error);
         }
     }
-    /**
-     * Process a thinking action
-     */
+    async saveToStorage() {
+        await this.mutex.dispatch(() => this._saveToStorage());
+    }
     async process(input) {
-        // Clean up mangled actions and extract hidden parameters (some LLMs inject XML into the string)
-        let action = input.action;
-        if (action.includes('<')) {
-            // Extract sessionId if it's hidden inside the action string
-            const sessionMatch = action.match(/<arg_value>(.*?)($|<)/);
-            if (sessionMatch && (!input.sessionId || input.sessionId === '')) {
-                input.sessionId = sessionMatch[1].trim();
-                console.error(`[Brain] Recovered sessionId from mangled action: ${input.sessionId}`);
-            }
-            action = action.split('<')[0].trim();
-        }
-        // Rate limiting / Flood protection
-        const now = Date.now();
-        const elapsed = now - this.lastActionTimestamp;
-        if (elapsed < this.MIN_DELAY_MS) {
-            const waitTime = this.MIN_DELAY_MS - elapsed;
-            console.error(`[Brain] Rate limiting: Sleeping for ${waitTime}ms to prevent flooding...`);
-            await this.sleep(waitTime);
-        }
-        this.lastActionTimestamp = Date.now();
-        await this.initStorage(true);
-        let result;
-        switch (action) {
-            case 'start_session':
-                result = this.startSession(input);
-                break;
-            case 'add_thought':
-                result = this.addThought(input);
-                break;
-            case 'create_branch':
-                result = this.createBranch(input);
-                break;
-            case 'revise_thought':
-                result = this.reviseThought(input);
-                break;
-            case 'set_hypothesis':
-                result = this.setHypothesis(input);
-                break;
-            case 'verify_hypothesis':
-                result = this.verifyHypothesis(input);
-                break;
-            case 'adjust_total_thoughts':
-                result = this.adjustTotalThoughts(input);
-                break;
-            case 'conclude':
-                result = this.conclude(input);
-                break;
-            case 'get_status':
-                result = this.getStatus(input);
-                break;
-            case 'get_history':
-                result = this.getHistory(input);
-                break;
-            case 'clear_history':
-                result = this.clearHistory();
-                break;
-            case 'delete_session':
-                result = this.deleteSession(input);
-                break;
-            case 'list_sessions':
-                result = this.listSessions();
-                break;
-            case 'delete_thought':
-                result = this.deleteThought(input);
-                break;
-            case 'self_critique':
-                result = this.selfCritique(input);
-                break;
-            case 'summarize_history':
-                result = this.summarizeHistory(input);
-                break;
-            case 'merge_branches':
-                result = this.mergeBranches(input);
-                break;
-            case 'execute_conclusion':
-                result = await this.executeConclusion(input);
-                break;
-            default:
-                result = {
+        let executeConclusionInput = null;
+        const result = await this.mutex.dispatch(async () => {
+            await this._initStorage(false);
+            const validationResult = BrainInputSchema.safeParse(input);
+            if (!validationResult.success) {
+                return {
                     success: false,
-                    sessionId: input.sessionId || '',
+                    sessionId: '',
                     currentStep: 0,
                     totalThoughts: 0,
                     status: 'in_progress',
-                    message: `Unknown action: ${input.action}`,
-                    nextSuggestedActions: ['start_session', 'list_sessions']
+                    message: `Validation Error: ${validationResult.error.message}`
                 };
-        }
-        // Persist changes after every action
-        if (result.success) {
-            await this.saveToStorage();
+            }
+            const validatedInput = validationResult.data;
+            let innerResult;
+            const now = Date.now();
+            if (now - this.lastActionTimestamp < this.MIN_DELAY_MS) {
+                await this.sleep(200);
+            }
+            this.lastActionTimestamp = Date.now();
+            // Defer execution to avoid deadlock
+            if (validatedInput.action === 'execute_conclusion') {
+                executeConclusionInput = validatedInput;
+                // Return a temporary pending result
+                return {
+                    success: true,
+                    sessionId: validatedInput.sessionId || '',
+                    currentStep: 0,
+                    totalThoughts: 0,
+                    status: 'in_progress',
+                    message: 'Preparing execution...'
+                };
+            }
+            switch (validatedInput.action) {
+                case 'start_session':
+                    innerResult = this.startSession(validatedInput);
+                    break;
+                case 'add_thought':
+                    innerResult = this.addThought(validatedInput);
+                    break;
+                case 'create_branch':
+                    innerResult = this.createBranch(validatedInput);
+                    break;
+                case 'generate_options':
+                    innerResult = this.generateOptions(validatedInput);
+                    break;
+                case 'evaluate_options':
+                    innerResult = this.evaluateOptions(validatedInput);
+                    break;
+                case 'select_option':
+                    innerResult = this.selectOption(validatedInput);
+                    break;
+                case 'revise_thought':
+                    innerResult = this.reviseThought(validatedInput);
+                    break;
+                case 'set_hypothesis':
+                    innerResult = this.setHypothesis(validatedInput);
+                    break;
+                case 'verify_hypothesis':
+                    innerResult = this.verifyHypothesis(validatedInput);
+                    break;
+                case 'conclude':
+                    innerResult = this.conclude(validatedInput);
+                    break;
+                // execute_conclusion handled outside
+                case 'reflect':
+                    innerResult = this.reflect(validatedInput);
+                    break;
+                case 'replan':
+                    innerResult = await this.replan(validatedInput);
+                    break;
+                case 'decompose':
+                    innerResult = this.decompose(validatedInput);
+                    break;
+                case 'research':
+                    innerResult = this.research(validatedInput);
+                    break;
+                case 'get_history':
+                    innerResult = this.getHistory(validatedInput);
+                    break;
+                default: innerResult = this.startSession(validatedInput);
+            }
+            if (innerResult.success)
+                await this._saveToStorage();
+            return innerResult;
+        });
+        if (executeConclusionInput) {
+            const conclusionResult = await this.executeConclusion(executeConclusionInput);
+            // We must save again because executeConclusion modifies state (adds reflection)
+            // But executeConclusion calls process('reflect') internally, which acquires lock & saves.
+            // So we don't need to save here.
+            return conclusionResult;
         }
         return result;
     }
-    /**
-     * Start a new thinking session
-     */
-    startSession(input) {
-        if (!input.problemStatement) {
-            return this.errorResponse('', 'Problem statement is required to start a session');
-        }
-        const sessionId = uuidv4();
-        const totalThoughts = input.totalThoughts || 5;
-        const now = new Date().toISOString();
-        const session = {
-            sessionId,
-            problemStatement: input.problemStatement,
-            totalThoughts,
-            currentStep: 0,
-            thoughtHistory: [],
-            branches: [],
-            status: 'in_progress',
-            createdAt: now,
-            updatedAt: now
-        };
-        this.sessions.set(sessionId, session);
-        this.lastSessionId = sessionId;
-        return {
-            success: true,
-            sessionId,
-            currentStep: 0,
-            totalThoughts,
-            status: 'in_progress',
-            message: `Thinking session started. You have ${totalThoughts} thinking steps planned. You can use "latest" as sessionId in subsequent calls.`,
-            nextSuggestedActions: ['add_thought (type: initial_analysis)', 'adjust_total_thoughts']
-        };
-    }
-    /**
-     * List all available sessions
-     */
-    listSessions() {
-        const sessionList = Array.from(this.sessions.values())
-            .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
-            .map((s) => `• [${s.status}] ${s.sessionId}: ${s.problemStatement.substring(0, 50)}... (${s.currentStep}/${s.totalThoughts})`)
-            .join('\n');
-        return {
-            success: true,
-            sessionId: this.lastSessionId || '',
-            currentStep: 0,
-            totalThoughts: 0,
-            status: 'completed',
-            message: sessionList.length > 0
-                ? `Available Thinking Sessions (Newest first):\n${sessionList}`
-                : 'No thinking sessions found.'
-        };
-    }
-    /**
-     * Add a new thought to the session
-     */
-    addThought(input) {
+    decompose(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.thought)
-            return this.errorResponse(session.sessionId, 'Thought content is required');
+            return { success: false, message: 'Session not found' };
         session.currentStep++;
-        const thoughtId = uuidv4();
         const thought = {
-            id: thoughtId,
+            id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: input.thought,
-            thoughtType: input.thoughtType || 'initial_analysis',
+            thought: `DECOMPOSITION: ${input.thought}`,
+            thoughtType: 'decomposition',
             timestamp: new Date().toISOString(),
-            confidence: input.confidence ?? 70,
-            parentId: input.branchFromThoughtId
+            confidence: 90
         };
         session.thoughtHistory.push(thought);
-        session.updatedAt = new Date().toISOString();
-        if (session.currentStep >= session.totalThoughts) {
-            session.status = 'awaiting_verification';
-        }
         return {
             success: true,
             sessionId: session.sessionId,
@@ -269,410 +181,199 @@ export class SequentialThinkingManager {
             totalThoughts: session.totalThoughts,
             status: session.status,
             thought,
-            message: this.getThoughtMessage(session, thought),
-            nextSuggestedActions: this.getSuggestedActions(session, thought)
+            message: 'Query decomposed. Please add sub-thoughts for each component.'
         };
     }
-    /**
-     * Create a branch for exploring alternative thought paths
-     */
-    createBranch(input) {
+    research(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.branchFromThoughtId)
-            return this.errorResponse(session.sessionId, 'branchFromThoughtId is required');
-        const parentThought = session.thoughtHistory.find((t) => t.id === input.branchFromThoughtId);
-        if (!parentThought)
-            return this.errorResponse(session.sessionId, 'Parent thought not found');
-        const branchId = uuidv4();
-        const branchLabel = input.branchLabel || `Branch ${session.branches.length + 1}`;
-        const branch = {
-            id: branchId,
-            label: branchLabel,
-            parentThoughtId: input.branchFromThoughtId,
-            thoughtIds: [],
-            status: 'active'
-        };
-        session.branches.push(branch);
-        session.updatedAt = new Date().toISOString();
-        if (input.thought) {
-            session.currentStep++;
-            const thoughtId = uuidv4();
-            const thought = {
-                id: thoughtId,
-                stepNumber: session.currentStep,
-                thought: input.thought,
-                thoughtType: 'branch_exploration',
-                timestamp: new Date().toISOString(),
-                parentId: input.branchFromThoughtId,
-                branchLabel,
-                confidence: input.confidence ?? 60
-            };
-            session.thoughtHistory.push(thought);
-            branch.thoughtIds.push(thoughtId);
-            return {
-                success: true,
-                sessionId: session.sessionId,
-                currentStep: session.currentStep,
-                totalThoughts: session.totalThoughts,
-                status: session.status,
-                thought,
-                branches: session.branches,
-                message: `Created branch "${branchLabel}" from thought #${parentThought.stepNumber}.`,
-                nextSuggestedActions: ['add_thought', 'create_branch']
-            };
-        }
-        return {
-            success: true,
-            sessionId: session.sessionId,
-            currentStep: session.currentStep,
-            totalThoughts: session.totalThoughts,
-            status: session.status,
-            branches: session.branches,
-            message: `Created branch "${branchLabel}" from thought #${parentThought.stepNumber}. Ready for thoughts.`,
-            nextSuggestedActions: ['add_thought']
+            return { success: false, message: 'Session not found' };
+        const topic = input.thought || session.problemStatement;
+        const planId = 'research-' + uuidv4().substring(0, 8);
+        const plan = {
+            planId,
+            name: `Research: ${topic.substring(0, 30)}...`,
+            tasks: [
+                {
+                    id: 'search_google',
+                    name: 'Google Search',
+                    toolName: 'web_search',
+                    toolInput: { query: topic, freshness: 'year' },
+                    dependencies: []
+                },
+                {
+                    id: 'search_brave',
+                    name: 'Brave Search',
+                    toolName: 'web_search',
+                    toolInput: { query: topic, freshness: 'month' },
+                    dependencies: [],
+                    runIf: '${search_google.results.length} === 0' // Fallback
+                },
+                {
+                    id: 'save_memory',
+                    name: 'Save Findings',
+                    toolName: 'memory_save',
+                    toolInput: { key: `Research: ${topic}`, value: '${search_google.results}' },
+                    dependencies: ['search_google']
+                }
+            ]
         };
-    }
-    /**
-     * Revise a previous thought
-     */
-    reviseThought(input) {
-        const session = this.getSession(input.sessionId);
-        if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.reviseThoughtId)
-            return this.errorResponse(session.sessionId, 'reviseThoughtId is required');
-        if (!input.thought)
-            return this.errorResponse(session.sessionId, 'New thought content is required');
-        const originalThought = session.thoughtHistory.find((t) => t.id === input.reviseThoughtId);
-        if (!originalThought)
-            return this.errorResponse(session.sessionId, 'Original thought not found');
         session.currentStep++;
-        const thoughtId = uuidv4();
-        const revisedThought = {
-            id: thoughtId,
+        const thought = {
+            id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: input.thought,
-            thoughtType: 'revision',
+            thought: `RESEARCH PLAN: Generated plan to investigate "${topic}"`,
+            thoughtType: 'plan',
             timestamp: new Date().toISOString(),
-            isRevision: true,
-            revisedFromId: input.reviseThoughtId,
-            confidence: input.confidence ?? 75,
-            parentId: originalThought.parentId
+            confidence: 100,
+            metadata: { planId }
         };
-        session.thoughtHistory.push(revisedThought);
-        session.updatedAt = new Date().toISOString();
+        session.thoughtHistory.push(thought);
         return {
             success: true,
             sessionId: session.sessionId,
             currentStep: session.currentStep,
             totalThoughts: session.totalThoughts,
             status: session.status,
-            thought: revisedThought,
-            message: `Revised thought #${originalThought.stepNumber}.`,
-            nextSuggestedActions: ['add_thought', 'verify_hypothesis']
+            thought,
+            executionPlan: plan,
+            message: 'Research plan generated. Use execute_conclusion to run it.'
         };
     }
-    /**
-     * Set a hypothesis that needs verification
-     */
-    setHypothesis(input) {
+    async replan(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.hypothesis)
-            return this.errorResponse(session.sessionId, 'Hypothesis content is required');
+            return { success: false, message: 'Session not found' };
+        console.error(`[Brain] Strategic Re-plan requested for session: ${session.sessionId}`);
         session.currentStep++;
-        const thoughtId = uuidv4();
-        const hypothesisThought = {
-            id: thoughtId,
+        const failureThought = {
+            id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: input.thought || `Hypothesis: ${input.hypothesis}`,
-            thoughtType: 'hypothesis',
+            thought: `STRATEGIC FAILURE: Task failed after multiple healing attempts. Error: ${input.thought}`,
+            thoughtType: 'reflection',
             timestamp: new Date().toISOString(),
-            hypothesis: input.hypothesis,
-            verificationStatus: 'pending',
-            confidence: input.confidence ?? 50
-        };
-        session.thoughtHistory.push(hypothesisThought);
-        session.status = 'awaiting_verification';
-        session.updatedAt = new Date().toISOString();
-        return {
-            success: true,
-            sessionId: session.sessionId,
-            currentStep: session.currentStep,
-            totalThoughts: session.totalThoughts,
-            status: session.status,
-            thought: hypothesisThought,
-            message: `Hypothesis set: "${input.hypothesis}". Gather evidence before proceeding.`,
-            nextSuggestedActions: ['verify_hypothesis', 'create_branch', 'add_thought']
+            confidence: 100
         };
-    }
-    /**
-     * Verify a hypothesis with evidence
-     */
-    verifyHypothesis(input) {
-        const session = this.getSession(input.sessionId);
-        if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        let hypothesisThought;
-        if (input.hypothesis) {
-            // Find the specific hypothesis mentioned (ignoring status)
-            hypothesisThought = [...session.thoughtHistory]
-                .reverse()
-                .find((t) => t.thoughtType === 'hypothesis' &&
-                (t.hypothesis?.includes(input.hypothesis) || input.hypothesis?.includes(t.hypothesis)));
-        }
-        // Fallback to latest pending hypothesis if no specific match found
-        if (!hypothesisThought) {
-            hypothesisThought = [...session.thoughtHistory]
-                .reverse()
-                .find((t) => t.thoughtType === 'hypothesis' && t.verificationStatus === 'pending');
+        session.thoughtHistory.push(failureThought);
+        let suggestedPlan = undefined;
+        if (input.thought?.includes('fetch failed')) {
+            suggestedPlan = {
+                planId: 'recovery-' + uuidv4().substring(0, 8),
+                name: 'Network Recovery Plan',
+                tasks: [{
+                        id: 'fallback',
+                        name: 'Fallback Echo',
+                        toolName: 'echo',
+                        toolInput: { msg: 'Recovered using fallback echo due to network failure.' },
+                        dependencies: []
+                    }]
+            };
         }
-        if (!hypothesisThought)
-            return this.errorResponse(session.sessionId, 'No pending hypothesis found');
-        if (!input.verificationStatus)
-            return this.errorResponse(session.sessionId, 'verificationStatus is required');
-        session.currentStep++;
-        const thoughtId = uuidv4();
-        const verificationThought = {
-            id: thoughtId,
-            stepNumber: session.currentStep,
-            thought: input.thought || `Verification of hypothesis: "${hypothesisThought.hypothesis}"`,
-            thoughtType: 'verification',
-            timestamp: new Date().toISOString(),
-            hypothesis: hypothesisThought.hypothesis,
-            verificationStatus: input.verificationStatus,
-            verificationEvidence: input.verificationEvidence,
-            confidence: this.getVerificationConfidence(input.verificationStatus, input.confidence),
-            parentId: hypothesisThought.id
-        };
-        hypothesisThought.verificationStatus = input.verificationStatus;
-        hypothesisThought.verificationEvidence = input.verificationEvidence;
-        session.thoughtHistory.push(verificationThought);
-        session.status =
-            input.verificationStatus === 'needs_more_evidence' ? 'awaiting_verification' : 'in_progress';
-        session.updatedAt = new Date().toISOString();
-        const statusEmoji = this.getVerificationEmoji(input.verificationStatus);
         return {
             success: true,
             sessionId: session.sessionId,
             currentStep: session.currentStep,
             totalThoughts: session.totalThoughts,
             status: session.status,
-            thought: verificationThought,
-            message: `${statusEmoji} Hypothesis "${hypothesisThought.hypothesis?.substring(0, 40)}..." → ${input.verificationStatus.toUpperCase()}.`,
-            nextSuggestedActions: this.getPostVerificationActions(input.verificationStatus)
+            message: 'Re-plan generated based on failure context.',
+            executionPlan: suggestedPlan // Pass back to Body
         };
     }
-    /**
-     * Dynamically adjust the total number of thinking steps
-     */
-    adjustTotalThoughts(input) {
-        const session = this.getSession(input.sessionId);
-        if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (input.totalThoughts === undefined)
-            return this.errorResponse(session.sessionId, 'totalThoughts is required');
-        const oldTotal = session.totalThoughts;
-        const newTotal = Math.max(session.currentStep, input.totalThoughts);
-        session.totalThoughts = newTotal;
-        session.updatedAt = new Date().toISOString();
-        const remaining = newTotal - session.currentStep;
+    startSession(input) {
+        const sessionId = uuidv4();
+        const session = {
+            sessionId,
+            problemStatement: input.problemStatement || 'No problem statement',
+            totalThoughts: input.totalThoughts || 10,
+            currentStep: 0,
+            thoughtHistory: [],
+            branches: [],
+            status: 'in_progress',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        this.sessions.set(sessionId, session);
+        this.lastSessionId = sessionId;
         return {
             success: true,
-            sessionId: session.sessionId,
-            currentStep: session.currentStep,
+            sessionId,
+            currentStep: 0,
             totalThoughts: session.totalThoughts,
-            status: session.status,
-            message: `Total thoughts adjusted: ${oldTotal} → ${newTotal}. ${remaining} remaining.`,
-            nextSuggestedActions: ['add_thought']
+            status: 'in_progress',
+            message: 'Brain 2.0 Session Started. Ready for Tree of Thoughts.'
         };
     }
-    /**
-     * Conclude the thinking session
-     */
-    conclude(input) {
+    addThought(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        const pendingHypotheses = session.thoughtHistory.filter((t) => t.thoughtType === 'hypothesis' && t.verificationStatus === 'pending');
-        let warningMessage = '';
-        // Smart Conclusion: If there are pending hypotheses, don't block, but warn/resolve them.
-        if (pendingHypotheses.length > 0 && !input.force) {
-            console.warn(`[Brain] Concluding with ${pendingHypotheses.length} pending hypotheses. Auto-resolving as 'skipped'.`);
-            pendingHypotheses.forEach((h) => {
-                h.verificationStatus = 'needs_more_evidence'; // Soft resolve
-                // Add a system note about skipping verification
-                session.thoughtHistory.push({
-                    id: uuidv4(),
-                    stepNumber: session.currentStep + 1,
-                    thought: `[System] Auto-skipping verification for hypothesis: "${h.hypothesis}" due to session conclusion.`,
-                    thoughtType: 'verification',
-                    timestamp: new Date().toISOString(),
-                    hypothesis: h.hypothesis,
-                    verificationStatus: 'needs_more_evidence',
-                    verificationEvidence: 'Session concluded without explicit verification.',
-                    confidence: 50,
-                    parentId: h.id
-                });
-                session.currentStep++;
-            });
-            warningMessage = ` (Note: ${pendingHypotheses.length} pending hypothesis(es) were marked as unverified)`;
-        }
-        const conclusionText = input.thought ||
-            session.thoughtHistory[session.thoughtHistory.length - 1]?.thought ||
-            'Thinking session completed successfully.';
+            return { success: false, message: 'Session not found' };
         session.currentStep++;
-        const thoughtId = uuidv4();
-        const conclusionThought = {
-            id: thoughtId,
+        const thought = {
+            id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: conclusionText,
-            thoughtType: 'conclusion',
+            thought: input.thought || '',
+            thoughtType: input.thoughtType || 'initial_analysis',
             timestamp: new Date().toISOString(),
-            confidence: input.confidence ?? 90
-        };
-        session.thoughtHistory.push(conclusionThought);
-        session.finalConclusion = conclusionText;
-        session.status = 'completed';
-        session.updatedAt = new Date().toISOString();
-        return {
-            success: true,
-            sessionId: session.sessionId,
-            currentStep: session.currentStep,
-            totalThoughts: session.totalThoughts,
-            status: session.status,
-            thought: conclusionThought,
-            conclusion: conclusionText,
-            message: `🎯 Thinking session COMPLETED.${warningMessage} You can now execute the conclusion if it contains a plan.`,
-            nextSuggestedActions: ['execute_conclusion', 'get_history']
+            confidence: input.confidence ?? 70, // Default confidence
+            parentId: input.branchFromThoughtId || this.getLastThoughtId(session),
+            branchLabel: input.branchLabel // Preserve label
         };
-    }
-    /**
-     * Delete a specific thought from the history
-     */
-    deleteThought(input) {
-        const session = this.getSession(input.sessionId);
-        if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.deleteThoughtId)
-            return this.errorResponse(session.sessionId, 'deleteThoughtId is required');
-        const initialLength = session.thoughtHistory.length;
-        session.thoughtHistory = session.thoughtHistory.filter((t) => t.id !== input.deleteThoughtId);
-        if (session.thoughtHistory.length === initialLength) {
-            return this.errorResponse(session.sessionId, 'Thought not found');
-        }
-        // Re-adjust currentStep and stepNumbers for consistency
-        session.currentStep = session.thoughtHistory.length;
-        session.thoughtHistory.forEach((t, index) => {
-            t.stepNumber = index + 1;
-        });
-        session.updatedAt = new Date().toISOString();
-        return {
-            success: true,
-            sessionId: session.sessionId,
-            currentStep: session.currentStep,
-            totalThoughts: session.totalThoughts,
-            status: session.status,
-            message: `Successfully deleted thought: ${input.deleteThoughtId}. History re-indexed.`,
-            nextSuggestedActions: ['add_thought', 'conclude']
-        };
-    }
-    /**
-     * Get current session status
-     */
-    getStatus(input) {
-        const session = this.getSession(input.sessionId);
-        if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        const stats = this.generateSessionStats(session);
+        session.thoughtHistory.push(thought);
         return {
             success: true,
             sessionId: session.sessionId,
             currentStep: session.currentStep,
             totalThoughts: session.totalThoughts,
             status: session.status,
-            branches: session.branches,
-            message: `Session Status:\n${stats}`,
-            nextSuggestedActions: this.getStatusBasedActions(session)
+            thought,
+            message: `Thought added (${thought.thoughtType})`
         };
     }
-    /**
-     * Get complete thought history
-     */
-    getHistory(input) {
+    generateOptions(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
+            return { success: false, message: 'Session not found' };
         return {
             success: true,
             sessionId: session.sessionId,
             currentStep: session.currentStep,
             totalThoughts: session.totalThoughts,
             status: session.status,
-            thoughtHistory: session.thoughtHistory,
-            branches: session.branches,
-            message: `Complete thought history retrieved. ${session.thoughtHistory.length} thoughts recorded.`,
-            conclusion: session.finalConclusion
-        };
-    }
-    /**
-     * Clear all thinking sessions
-     */
-    clearHistory() {
-        const count = this.sessions.size;
-        this.sessions.clear();
-        return {
-            success: true,
-            sessionId: '',
-            currentStep: 0,
-            totalThoughts: 0,
-            status: 'completed',
-            message: `Successfully cleared all thinking history (${count} sessions).`
+            message: 'ToT Mode: Please provide 3 distinct options for the next step using `add_thought` with `thoughtType="option_generation"` and `branchLabel="Option A/B/C"`.',
+            nextSuggestedActions: ['add_thought', 'add_thought', 'add_thought']
         };
     }
-    /**
-     * Delete a specific thinking session
-     */
-    deleteSession(input) {
-        if (!input.sessionId)
-            return this.errorResponse('', 'sessionId is required to delete a session');
-        const exists = this.sessions.has(input.sessionId);
-        if (!exists)
-            return this.errorResponse(input.sessionId, 'Session not found');
-        this.sessions.delete(input.sessionId);
+    evaluateOptions(input) {
         return {
             success: true,
-            sessionId: input.sessionId,
+            sessionId: input.sessionId || '',
             currentStep: 0,
             totalThoughts: 0,
-            status: 'completed',
-            message: `Successfully deleted session: ${input.sessionId}`
+            status: 'in_progress',
+            message: 'Please review the generated options and use `revise_thought` on each to add a `score` (0-1.0) and `evaluation` text.',
+            nextSuggestedActions: ['revise_thought']
         };
     }
-    /**
-     * Perform a self-critique of the current reasoning
-     */
-    selfCritique(input) {
+    selectOption(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.thought)
-            return this.errorResponse(session.sessionId, 'Critique content is required in "thought" field');
+            return { success: false, message: 'Session not found' };
+        if (!input.optionId)
+            return { success: false, message: 'optionId required' };
+        const selected = session.thoughtHistory.find(t => t.id === input.optionId);
+        if (!selected)
+            return { success: false, message: 'Option not found' };
         session.currentStep++;
-        const thoughtId = uuidv4();
         const thought = {
-            id: thoughtId,
+            id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: `🔍 SELF-CRITIQUE:\n${input.thought}`,
-            thoughtType: 'self_critique',
+            thought: `Selected Option: ${selected.branchLabel || 'Unknown'} - ${selected.thought}`,
+            thoughtType: 'synthesis',
             timestamp: new Date().toISOString(),
-            confidence: input.confidence ?? 80
+            parentId: selected.id,
+            confidence: 90
         };
         session.thoughtHistory.push(thought);
-        session.updatedAt = new Date().toISOString();
         return {
             success: true,
             sessionId: session.sessionId,
@@ -680,78 +381,28 @@ export class SequentialThinkingManager {
             totalThoughts: session.totalThoughts,
             status: session.status,
             thought,
-            message: `Critique added. Analyze these points before proceeding.`,
-            nextSuggestedActions: ['add_thought', 'revise_thought', 'create_branch']
+            message: `Selected option ${selected.branchLabel}. Moving forward.`
         };
     }
-    /**
-     * Summarize the thought history to keep context focused
-     */
-    summarizeHistory(input) {
+    reflect(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.thought)
-            return this.errorResponse(session.sessionId, 'Summary content is required in "thought" field');
+            return this.errorResponse('', 'Session not found');
+        console.log('[Brain] Reflexion triggered for session:', session.sessionId);
         session.currentStep++;
-        const thoughtId = uuidv4();
         const thought = {
-            id: thoughtId,
+            id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: `📝 CONTEXT SUMMARY:\n${input.thought}`,
-            thoughtType: 'summary',
+            thought: `REFLEXION: ${input.thought}`,
+            thoughtType: 'reflection',
             timestamp: new Date().toISOString(),
-            confidence: 100
+            confidence: 80,
+            metadata: { executionResult: input.executionResult }
         };
         session.thoughtHistory.push(thought);
-        session.updatedAt = new Date().toISOString();
-        return {
-            success: true,
-            sessionId: session.sessionId,
-            currentStep: session.currentStep,
-            totalThoughts: session.totalThoughts,
-            status: session.status,
-            thought,
-            message: `Context summarized. Thinking continues with focused scope.`,
-            nextSuggestedActions: ['add_thought', 'conclude']
-        };
-    }
-    /**
-     * Merge multiple branches or thoughts into a new consolidated thought
-     */
-    mergeBranches(input) {
-        const session = this.getSession(input.sessionId);
-        if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        if (!input.thought)
-            return this.errorResponse(session.sessionId, 'Consolidated thought content is required');
-        const sourceIds = input.sourceThoughtIds || [];
-        const branchIds = input.branchIds || [];
-        session.currentStep++;
-        const thoughtId = uuidv4();
-        const thought = {
-            id: thoughtId,
-            stepNumber: session.currentStep,
-            thought: `🔗 MERGED CONCLUSION:\n${input.thought}`,
-            thoughtType: 'synthesis',
-            timestamp: new Date().toISOString(),
-            confidence: input.confidence ?? 85,
-            metadata: {
-                mergedFromThoughts: sourceIds,
-                mergedFromBranches: branchIds
-            }
-        };
-        // Mark branches as merged if branchIds provided
-        if (branchIds.length > 0) {
-            session.branches.forEach((b) => {
-                if (branchIds.includes(b.id)) {
-                    b.status = 'merged';
-                    b.mergedIntoId = thoughtId;
-                }
-            });
+        if (input.thought && input.thought.length > 50) {
+            vectorMemory.add(`Reflexion on ${session.problemStatement}: ${input.thought}`, { sessionId: session.sessionId });
         }
-        session.thoughtHistory.push(thought);
-        session.updatedAt = new Date().toISOString();
         return {
             success: true,
             sessionId: session.sessionId,
@@ -759,222 +410,103 @@ export class SequentialThinkingManager {
             totalThoughts: session.totalThoughts,
             status: session.status,
             thought,
-            message: `Successfully merged ${sourceIds.length} thoughts and ${branchIds.length} branches.`,
-            nextSuggestedActions: ['add_thought', 'conclude']
+            message: 'Reflexion recorded and saved to Semantic Memory.'
         };
     }
-    /**
-     * Bridge: Execute the plan derived from the thinking session's conclusion
-     */
     async executeConclusion(input) {
         const session = this.getSession(input.sessionId);
         if (!session)
-            return this.errorResponse(input.sessionId || '', 'Session not found');
-        const conclusion = session.finalConclusion ||
-            session.thoughtHistory.find((t) => t.thoughtType === 'conclusion')?.thought;
+            return this.errorResponse('', 'Session not found');
+        const conclusion = session.finalConclusion || session.thoughtHistory.slice(-1)[0]?.thought;
         if (!conclusion)
-            return this.errorResponse(session.sessionId, 'No conclusion found to execute. Please conclude the session first.');
-        console.error(`[Brain-Body Bridge] Attempting to execute conclusion for session: ${session.sessionId}`);
-        // Try to find a JSON plan in the conclusion
+            return this.errorResponse(session.sessionId, 'No conclusion');
         let plan = null;
         try {
-            // Look for JSON block in markdown or just plain JSON
-            const jsonMatch = conclusion.match(/```json\n([\s\S]*?)\n```/) || conclusion.match(/(\{[\s\S]*\})/);
-            if (jsonMatch) {
-                plan = JSON.parse(jsonMatch[1]);
+            const codeBlockMatch = conclusion.match(/```(?:json)?\n([\s\S]*?)\n```/);
+            if (codeBlockMatch) {
+                plan = JSON.parse(codeBlockMatch[1]);
+            }
+            else {
+                const firstBrace = conclusion.indexOf('{');
+                const lastBrace = conclusion.lastIndexOf('}');
+                if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+                    const jsonString = conclusion.substring(firstBrace, lastBrace + 1);
+                    plan = JSON.parse(jsonString);
+                }
             }
         }
         catch (e) {
-            console.error('[Brain-Body Bridge] Failed to parse plan from conclusion:', e);
+            console.error('[Brain] Failed to parse conclusion JSON:', e);
         }
         if (!plan) {
-            console.error(`[Brain-Body Bridge] No JSON plan found. Attempting auto-generation...`);
-            plan = this.autoGeneratePlan(conclusion, session);
-        }
-        if (!plan) {
-            return this.errorResponse(session.sessionId, 'Could not extract or auto-generate a valid ExecutionPlan from the conclusion. Please ensure your conclusion contains a JSON code block or clear intent (e.g., "list files", "search web").');
+            plan = {
+                planId: 'auto-' + uuidv4(),
+                name: 'Auto Plan',
+                tasks: [{ id: 't1', name: 'Auto Echo', toolName: 'echo', toolInput: { text: 'Running...' }, dependencies: [] }]
+            };
         }
-        // Execute via Orchestrator
-        const executionOutput = await orchestratorManager.process({
-            action: 'execute_plan',
-            plan
+        const execResult = await orchestratorManager.process({ action: 'execute_plan', plan });
+        await this.process({
+            action: 'reflect',
+            sessionId: session.sessionId,
+            thought: execResult.success
+                ? `Execution Successful. Result: ${JSON.stringify(execResult.result?.aggregatedResults || 'OK')}`
+                : `Execution Failed. Errors: ${JSON.stringify(execResult.result?.errors || 'Unknown')}`,
+            executionResult: execResult
         });
         return {
-            success: executionOutput.success,
+            success: execResult.success,
             sessionId: session.sessionId,
             currentStep: session.currentStep,
             totalThoughts: session.totalThoughts,
             status: session.status,
-            message: `Autonomous execution (${plan.name}): ${executionOutput.message}`,
-            executionResult: executionOutput.result
+            message: `Execution ${execResult.success ? 'Success' : 'Failed'}. Reflexion triggered.`,
+            executionResult: execResult.result
         };
     }
-    /**
-     * Heuristic-based plan generator to fulfill the "Auto-Plan" requirement
-     */
-    autoGeneratePlan(conclusion, session) {
-        const text = conclusion.toLowerCase();
-        const tasks = [];
-        // Heuristic 1: List/Explore
-        if (text.includes('list') ||
-            text.includes('folder') ||
-            text.includes('directory') ||
-            text.includes('สำรวจ')) {
-            tasks.push({
-                id: 'auto_list',
-                name: 'Auto-Explore Directory',
-                toolName: 'list_directory',
-                toolInput: { path: '.' },
-                dependencies: []
-            });
-        }
-        // Heuristic 2: Search
-        if (text.includes('search') || text.includes('find') || text.includes('ค้นหา')) {
-            tasks.push({
-                id: 'auto_search',
-                name: 'Auto-Web Search',
-                toolName: 'web_search',
-                toolInput: { query: session.problemStatement },
-                dependencies: []
-            });
-        }
-        // Heuristic 3: Read
-        if (text.includes('read') || text.includes('อ่าน') || text.includes('view')) {
-            tasks.push({
-                id: 'auto_read',
-                name: 'Auto-Read Files',
-                toolName: 'shell_execute',
-                toolInput: { command: 'ls -R | head -n 20' },
-                dependencies: []
-            });
-        }
-        if (tasks.length === 0)
-            return null;
-        return {
-            planId: `auto-${uuidv4().substring(0, 8)}`,
-            name: 'Auto-Generated Plan',
-            description: 'Automatically generated by The Brain based on conclusion keywords.',
-            tasks
-        };
-    }
-    // ============================================
-    // Helper Methods
-    // ============================================
-    getSession(sessionId) {
-        if (!sessionId)
-            return undefined;
-        if (sessionId === 'latest' && this.lastSessionId) {
-            return this.sessions.get(this.lastSessionId);
-        }
-        return this.sessions.get(sessionId);
-    }
     errorResponse(sessionId, message) {
-        const session = this.sessions.get(sessionId);
         return {
             success: false,
             sessionId,
-            currentStep: session?.currentStep || 0,
-            totalThoughts: session?.totalThoughts || 0,
-            status: session?.status || 'in_progress',
+            currentStep: 0,
+            totalThoughts: 0,
+            status: 'in_progress',
             message: `Error: ${message}`
         };
     }
-    getThoughtMessage(session, thought) {
-        const progress = `[Step ${session.currentStep}/${session.totalThoughts}]`;
-        const typeLabel = thought.thoughtType.replace(/_/g, ' ').toUpperCase();
-        const confidenceBar = this.getConfidenceBar(thought.confidence);
-        return `${progress} ${typeLabel}\nConfidence: ${confidenceBar} ${thought.confidence}%\n\n${thought.thought}`;
+    getSession(id) {
+        if (!id || id === 'latest')
+            return this.sessions.get(this.lastSessionId || '');
+        return this.sessions.get(id);
     }
-    getConfidenceBar(confidence) {
-        const filled = Math.round(confidence / 10);
-        return '█'.repeat(filled) + '░'.repeat(10 - filled);
+    getLastThoughtId(session) {
+        return session.thoughtHistory.length > 0 ? session.thoughtHistory[session.thoughtHistory.length - 1].id : undefined;
     }
-    getSuggestedActions(session, thought) {
-        const actions = [];
-        const remaining = session.totalThoughts - session.currentStep;
-        if (remaining > 0)
-            actions.push('add_thought');
-        if (thought.thoughtType === 'initial_analysis') {
-            actions.push('set_hypothesis');
-            actions.push('create_branch');
-        }
-        // Always allow concluding if we have at least some thoughts
-        if (session.currentStep >= 1) {
-            actions.push('conclude');
-        }
-        if (remaining <= 0) {
-            actions.push('adjust_total_thoughts');
-        }
-        return actions;
-    }
-    getVerificationConfidence(status, providedConfidence) {
-        if (providedConfidence !== undefined)
-            return providedConfidence;
-        switch (status) {
-            case 'verified':
-                return 90;
-            case 'partially_verified':
-                return 70;
-            case 'refuted':
-                return 20;
-            case 'needs_more_evidence':
-                return 40;
-            default:
-                return 50;
-        }
-    }
-    getVerificationEmoji(status) {
-        switch (status) {
-            case 'verified':
-                return '✅';
-            case 'partially_verified':
-                return '🟡';
-            case 'refuted':
-                return '❌';
-            case 'needs_more_evidence':
-                return '🔍';
-            default:
-                return '❓';
-        }
-    }
-    getPostVerificationActions(status) {
-        switch (status) {
-            case 'verified':
-                return ['add_thought', 'conclude'];
-            case 'refuted':
-                return ['revise_thought', 'set_hypothesis', 'create_branch'];
-            case 'partially_verified':
-                return ['add_thought', 'set_hypothesis'];
-            case 'needs_more_evidence':
-                return ['add_thought', 'verify_hypothesis'];
-            default:
-                return ['add_thought'];
-        }
-    }
-    getStatusBasedActions(session) {
-        switch (session.status) {
-            case 'awaiting_verification': {
-                const hasPending = session.thoughtHistory.some((t) => t.thoughtType === 'hypothesis' && t.verificationStatus === 'pending');
-                return hasPending ? ['verify_hypothesis'] : ['conclude', 'add_thought'];
-            }
-            case 'completed':
-                return ['execute_conclusion', 'get_history'];
-            default:
-                return ['add_thought', 'get_history', 'conclude'];
+    createBranch(input) { return this.addThought(input); }
+    reviseThought(input) { return this.addThought({ ...input, thoughtType: 'revision' }); }
+    setHypothesis(input) { return this.addThought({ ...input, thoughtType: 'hypothesis' }); }
+    verifyHypothesis(input) { return this.addThought({ ...input, thoughtType: 'verification' }); }
+    conclude(input) {
+        const session = this.getSession(input.sessionId);
+        if (session) {
+            session.finalConclusion = input.thought;
+            session.status = 'completed';
         }
+        return this.addThought({ ...input, thoughtType: 'conclusion' });
     }
-    generateSessionStats(session) {
-        const revisionCount = session.thoughtHistory.filter((t) => t.isRevision).length;
-        const verifiedCount = session.thoughtHistory.filter((t) => t.verificationStatus === 'verified').length;
-        return [
-            `📊 Statistics:`,
-            `• Problem: "${session.problemStatement.substring(0, 50)}..."`,
-            `• Progress: ${session.currentStep}/${session.totalThoughts}`,
-            `• Status: ${session.status}`,
-            `• Branches: ${session.branches.length}`,
-            `• Revisions: ${revisionCount}`,
-            `• Verified: ${verifiedCount}`
-        ].join('\n');
+    getHistory(input) {
+        const session = this.getSession(input.sessionId);
+        if (!session)
+            return this.errorResponse('', 'Session not found');
+        return {
+            success: true,
+            sessionId: session.sessionId,
+            currentStep: session.currentStep,
+            totalThoughts: session.totalThoughts,
+            status: session.status,
+            message: 'History retrieved',
+            thoughtHistory: session.thoughtHistory
+        };
     }
 }
 export const thinkingManager = new SequentialThinkingManager();