@goonnguyen/human-mcp 2.1.0 → 2.2.0

package/dist/index.js

@@ -165962,6 +165962,2388 @@ async function handleVoiceCustomization(geminiClient, args, config) {
   };
 }
 
+// src/tools/brain/types.ts
+class ThinkingError extends Error {
+  code;
+  context;
+  constructor(message, code, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "ThinkingError";
+  }
+}
+class InvalidRevisionError extends ThinkingError {
+  constructor(thoughtNumber, maxThoughts) {
+    super(`Cannot revise thought ${thoughtNumber}: out of range (max: ${maxThoughts})`, "INVALID_REVISION", { thoughtNumber, maxThoughts });
+  }
+}
+
+class BranchingError extends ThinkingError {
+  constructor(reason) {
+    super(`Branching failed: ${reason}`, "BRANCHING_ERROR", { reason });
+  }
+}
+
+// src/tools/brain/utils/thought-manager.ts
+class ThoughtManager {
+  process;
+  options;
+  constructor(problem, thinkingStyle = "analytical", context, options = {}) {
+    this.options = {
+      maxThoughts: 10,
+      allowRevision: true,
+      enableBranching: true,
+      requireEvidence: false,
+      confidenceThreshold: 0.7,
+      timeLimit: 60,
+      outputDetail: "detailed",
+      ...options
+    };
+    this.process = {
+      id: v4_default(),
+      problem,
+      thoughts: [],
+      currentThought: 0,
+      totalThoughts: this.options.maxThoughts || 10,
+      branches: [],
+      hypotheses: [],
+      conclusions: [],
+      metadata: {
+        startTime: new Date,
+        thinkingStyle,
+        complexity: this.determineComplexity(problem),
+        domain: context?.domain,
+        revisionsCount: 0,
+        branchesCount: 0,
+        hypothesesCount: 0
+      }
+    };
+    logger2.info(`Starting thought process for: ${problem.substring(0, 100)}...`);
+  }
+  addThought(content, confidence = 0.8, options = {}) {
+    const thoughtStep = {
+      id: v4_default(),
+      number: this.process.currentThought + 1,
+      content,
+      confidence: Math.min(Math.max(confidence, 0), 1),
+      timestamp: new Date,
+      isRevision: options.isRevision || false,
+      revisesThought: options.revisesThought,
+      branchId: options.branchId,
+      branchFromThought: options.branchFromThought,
+      dependencies: options.dependencies,
+      tags: options.tags
+    };
+    if (options.isRevision && options.revisesThought) {
+      if (!this.options.allowRevision) {
+        throw new Error("Revision not allowed in current processing mode");
+      }
+      if (options.revisesThought > this.process.thoughts.length) {
+        throw new InvalidRevisionError(options.revisesThought, this.process.thoughts.length);
+      }
+      this.process.metadata.revisionsCount++;
+      thoughtStep.tags = [...thoughtStep.tags || [], "revision"];
+    }
+    if (options.branchId && options.branchFromThought) {
+      if (!this.options.enableBranching) {
+        throw new Error("Branching not allowed in current processing mode");
+      }
+      this.process.metadata.branchesCount++;
+      thoughtStep.tags = [...thoughtStep.tags || [], "branch"];
+    }
+    this.process.thoughts.push(thoughtStep);
+    this.process.currentThought = thoughtStep.number;
+    logger2.debug(`Added thought ${thoughtStep.number}: ${content.substring(0, 100)}...`);
+    return thoughtStep;
+  }
+  createBranch(fromThought, name, initialThought) {
+    if (!this.options.enableBranching) {
+      throw new BranchingError("Branching is disabled");
+    }
+    if (fromThought < 1 || fromThought > this.process.thoughts.length) {
+      throw new BranchingError(`Invalid thought number: ${fromThought}`);
+    }
+    const branch = {
+      id: v4_default(),
+      name,
+      fromThought,
+      thoughts: [],
+      isActive: true,
+      confidence: 0.5
+    };
+    if (initialThought) {
+      const branchThought = this.addThought(initialThought, 0.6, {
+        branchId: branch.id,
+        branchFromThought: fromThought,
+        tags: ["branch_start"]
+      });
+      branch.thoughts.push(branchThought);
+    }
+    this.process.branches.push(branch);
+    logger2.info(`Created branch "${name}" from thought ${fromThought}`);
+    return branch;
+  }
+  addHypothesis(statement, evidence = [], counterEvidence = [], confidence = 0.5) {
+    const hypothesis = {
+      id: v4_default(),
+      statement,
+      evidence,
+      counterEvidence,
+      confidence: Math.min(Math.max(confidence, 0), 1),
+      tested: false,
+      generatedAt: this.process.currentThought
+    };
+    this.process.hypotheses.push(hypothesis);
+    this.process.metadata.hypothesesCount++;
+    logger2.debug(`Added hypothesis: ${statement}`);
+    return hypothesis;
+  }
+  testHypothesis(hypothesisId, result, additionalEvidence) {
+    const hypothesis = this.process.hypotheses.find((h) => h.id === hypothesisId);
+    if (!hypothesis) {
+      throw new Error(`Hypothesis not found: ${hypothesisId}`);
+    }
+    hypothesis.tested = true;
+    hypothesis.result = result;
+    if (additionalEvidence) {
+      if (result === "confirmed") {
+        hypothesis.evidence.push(...additionalEvidence);
+      } else if (result === "rejected") {
+        hypothesis.counterEvidence.push(...additionalEvidence);
+      }
+    }
+    if (result === "confirmed") {
+      hypothesis.confidence = Math.min(hypothesis.confidence + 0.3, 1);
+    } else if (result === "rejected") {
+      hypothesis.confidence = Math.max(hypothesis.confidence - 0.4, 0);
+    }
+    logger2.info(`Tested hypothesis "${hypothesis.statement}": ${result}`);
+    return hypothesis;
+  }
+  addConclusion(statement, supportingThoughts, reasoning, confidence = 0.8, alternatives) {
+    const conclusion = {
+      id: v4_default(),
+      statement,
+      supportingThoughts,
+      confidence: Math.min(Math.max(confidence, 0), 1),
+      reasoning,
+      alternatives
+    };
+    this.process.conclusions.push(conclusion);
+    logger2.info(`Added conclusion: ${statement}`);
+    return conclusion;
+  }
+  getProcess() {
+    return { ...this.process };
+  }
+  getThoughts(filter) {
+    let thoughts = [...this.process.thoughts];
+    if (filter) {
+      if (filter.branchId) {
+        thoughts = thoughts.filter((t) => t.branchId === filter.branchId);
+      }
+      if (filter.tags) {
+        thoughts = thoughts.filter((t) => t.tags && filter.tags.some((tag) => t.tags.includes(tag)));
+      }
+      if (filter.minConfidence !== undefined) {
+        thoughts = thoughts.filter((t) => t.confidence >= filter.minConfidence);
+      }
+      if (filter.isRevision !== undefined) {
+        thoughts = thoughts.filter((t) => t.isRevision === filter.isRevision);
+      }
+    }
+    return thoughts;
+  }
+  getActiveHypotheses() {
+    return this.process.hypotheses.filter((h) => !h.tested);
+  }
+  getTestedHypotheses() {
+    return this.process.hypotheses.filter((h) => h.tested);
+  }
+  needsMoreThoughts() {
+    const avgConfidence = this.getAverageConfidence();
+    const hasConclusions = this.process.conclusions.length > 0;
+    const underThoughtLimit = this.process.currentThought < (this.options.maxThoughts || 10);
+    const underConfidenceThreshold = avgConfidence < (this.options.confidenceThreshold || 0.7);
+    return underThoughtLimit && (underConfidenceThreshold || !hasConclusions);
+  }
+  finalize() {
+    this.process.metadata.endTime = new Date;
+    this.process.metadata.totalDuration = this.process.metadata.endTime.getTime() - this.process.metadata.startTime.getTime();
+    logger2.info(`Finalized thought process with ${this.process.thoughts.length} thoughts`);
+    return this.process;
+  }
+  getAverageConfidence() {
+    if (this.process.thoughts.length === 0)
+      return 0;
+    const totalConfidence = this.process.thoughts.reduce((sum, thought) => sum + thought.confidence, 0);
+    return totalConfidence / this.process.thoughts.length;
+  }
+  determineComplexity(problem) {
+    const length = problem.length;
+    const technicalTerms = this.countTechnicalTerms(problem);
+    const questionComplexity = this.analyzeQuestionComplexity(problem);
+    if (length < 100 && technicalTerms < 2 && questionComplexity === "simple") {
+      return "simple";
+    } else if (length < 300 && technicalTerms < 5 && questionComplexity !== "expert") {
+      return "medium";
+    } else if (length < 800 && technicalTerms < 10) {
+      return "complex";
+    } else {
+      return "expert";
+    }
+  }
+  countTechnicalTerms(text) {
+    const technicalPatterns = [
+      /\b(algorithm|architecture|database|server|client|API|framework|library|protocol|interface|implementation|optimization|performance|scalability|security|authentication|authorization|encryption|deployment|infrastructure|microservice|container|docker|kubernetes|cloud|aws|azure|gcp)\b/gi,
+      /\b[A-Z]{2,}\b/g,
+      /\b\w+\.(js|ts|py|java|cpp|c|go|rust|php|rb|cs)\b/g
+    ];
+    return technicalPatterns.reduce((count, pattern) => {
+      const matches = text.match(pattern);
+      return count + (matches ? matches.length : 0);
+    }, 0);
+  }
+  analyzeQuestionComplexity(text) {
+    const complexKeywords = ["why", "how", "analyze", "compare", "evaluate", "design", "optimize", "troubleshoot"];
+    const expertKeywords = ["architect", "strategy", "paradigm", "methodology", "framework", "ecosystem"];
+    const hasComplexKeywords = complexKeywords.some((keyword) => text.toLowerCase().includes(keyword));
+    const hasExpertKeywords = expertKeywords.some((keyword) => text.toLowerCase().includes(keyword));
+    if (hasExpertKeywords)
+      return "expert";
+    if (hasComplexKeywords)
+      return "complex";
+    if (text.includes("?") || text.includes("explain"))
+      return "medium";
+    return "simple";
+  }
+}
+
+// src/tools/brain/utils/reasoning-engine.ts
+class ReasoningEngine {
+  geminiClient;
+  constructor(geminiClient) {
+    this.geminiClient = geminiClient;
+  }
+  async generateThought(problem, previousThoughts, thinkingStyle, thoughtNumber, context) {
+    const prompt = this.buildThoughtPrompt(problem, previousThoughts, thinkingStyle, thoughtNumber, context);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(prompt);
+      const result = response.response;
+      const content = result.text();
+      if (!content) {
+        throw new APIError("No content generated from reasoning engine");
+      }
+      const confidence = this.extractConfidence(content) || this.estimateConfidence(content, previousThoughts);
+      logger2.debug(`Generated thought ${thoughtNumber}: ${content.substring(0, 100)}...`);
+      return {
+        content: this.cleanThoughtContent(content),
+        confidence
+      };
+    } catch (error) {
+      logger2.error(`Failed to generate thought ${thoughtNumber}:`, error);
+      throw new APIError(`Failed to generate thought: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async generateHypothesis(problem, thoughts, thinkingStyle) {
+    const prompt = this.buildHypothesisPrompt(problem, thoughts, thinkingStyle);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(prompt);
+      const result = response.response;
+      const content = result.text();
+      if (!content) {
+        throw new APIError("No hypothesis generated");
+      }
+      const parsed = this.parseHypothesisResponse(content);
+      logger2.debug(`Generated hypothesis: ${parsed.statement}`);
+      return parsed;
+    } catch (error) {
+      logger2.error("Failed to generate hypothesis:", error);
+      throw new APIError(`Failed to generate hypothesis: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async testHypothesis(hypothesis, thoughts, additionalContext) {
+    const prompt = this.buildHypothesisTestPrompt(hypothesis, thoughts, additionalContext);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(prompt);
+      const result = response.response;
+      const content = result.text();
+      if (!content) {
+        throw new APIError("No hypothesis test result generated");
+      }
+      const parsed = this.parseHypothesisTestResponse(content);
+      logger2.info(`Tested hypothesis "${hypothesis.statement}": ${parsed.result}`);
+      return parsed;
+    } catch (error) {
+      logger2.error("Failed to test hypothesis:", error);
+      throw new APIError(`Failed to test hypothesis: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async synthesizeAnalysis(problem, thoughts, hypotheses, thinkingStyle, context) {
+    const prompt = this.buildSynthesisPrompt(problem, thoughts, hypotheses, thinkingStyle, context);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(prompt);
+      const result = response.response;
+      const content = result.text();
+      if (!content) {
+        throw new APIError("No synthesis generated");
+      }
+      const parsed = this.parseSynthesisResponse(content);
+      logger2.info(`Synthesized analysis with confidence ${parsed.confidence}`);
+      return parsed;
+    } catch (error) {
+      logger2.error("Failed to synthesize analysis:", error);
+      throw new APIError(`Failed to synthesize analysis: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  buildThoughtPrompt(problem, previousThoughts, thinkingStyle, thoughtNumber, context) {
+    const styleInstructions = this.getStyleInstructions(thinkingStyle);
+    const thoughtsContext = this.formatPreviousThoughts(previousThoughts);
+    const contextInfo = context ? this.formatContext(context) : "";
+    return `You are an expert reasoning system using ${thinkingStyle} thinking to analyze problems step by step.
+
+${styleInstructions}
+
+**Problem to analyze:**
+${problem}
+
+${contextInfo}
+
+**Previous thoughts (${previousThoughts.length}):**
+${thoughtsContext}
+
+**Current task:**
+Generate thought #${thoughtNumber} that builds on previous analysis. Be specific, logical, and provide actionable insights.
+
+**Requirements:**
+- Build upon previous thoughts without repeating them
+- Provide specific, concrete insights
+- Include confidence assessment
+- Consider evidence and assumptions
+- Identify gaps or questions if any
+
+**Response format:**
+Provide your thought followed by [Confidence: X.XX] where X.XX is a decimal between 0.00 and 1.00.
+
+Your thought #${thoughtNumber}:`;
+  }
+  buildHypothesisPrompt(problem, thoughts, thinkingStyle) {
+    const thoughtsContext = this.formatPreviousThoughts(thoughts);
+    return `Based on the analysis so far, generate a testable hypothesis about the problem.
+
+**Problem:**
+${problem}
+
+**Analysis so far:**
+${thoughtsContext}
+
+**Task:**
+Generate a specific, testable hypothesis that could explain or solve the problem.
+
+**Requirements:**
+- Make it specific and testable
+- Provide supporting evidence from the analysis
+- Include confidence level
+- Suggest how it could be tested
+
+**Response format:**
+HYPOTHESIS: [Your hypothesis statement]
+EVIDENCE: [Supporting evidence points, one per line]
+CONFIDENCE: [0.00-1.00]
+
+Your response:`;
+  }
+  buildHypothesisTestPrompt(hypothesis, thoughts, additionalContext) {
+    const thoughtsContext = this.formatPreviousThoughts(thoughts);
+    return `Evaluate the following hypothesis based on available evidence and reasoning.
+
+**Hypothesis to test:**
+${hypothesis.statement}
+
+**Supporting evidence:**
+${hypothesis.evidence.map((e) => `- ${e}`).join(`
+`)}
+
+**Counter evidence:**
+${hypothesis.counterEvidence.map((e) => `- ${e}`).join(`
+`)}
+
+**Analysis context:**
+${thoughtsContext}
+
+${additionalContext ? `**Additional context:**
+${additionalContext}
+` : ""}
+
+**Task:**
+Evaluate whether this hypothesis is confirmed, rejected, or inconclusive based on the evidence.
+
+**Response format:**
+RESULT: [CONFIRMED|REJECTED|INCONCLUSIVE]
+REASONING: [Detailed reasoning for your conclusion]
+EVIDENCE: [Additional evidence supporting your conclusion, one per line]
+
+Your evaluation:`;
+  }
+  buildSynthesisPrompt(problem, thoughts, hypotheses, thinkingStyle, context) {
+    const thoughtsContext = this.formatPreviousThoughts(thoughts);
+    const hypothesesContext = this.formatHypotheses(hypotheses);
+    const contextInfo = context ? this.formatContext(context) : "";
+    return `Synthesize a comprehensive analysis based on all the reasoning completed so far.
+
+**Original problem:**
+${problem}
+
+${contextInfo}
+
+**Complete thought process:**
+${thoughtsContext}
+
+**Hypotheses tested:**
+${hypothesesContext}
+
+**Task:**
+Provide a comprehensive final analysis that synthesizes all insights, conclusions, and recommendations.
+
+**Requirements:**
+- Summarize key findings and insights
+- Provide clear conclusions with confidence levels
+- Include actionable recommendations
+- Suggest logical next steps
+- Acknowledge limitations or uncertainties
+
+**Response format:**
+ANALYSIS: [Comprehensive analysis and conclusions]
+CONFIDENCE: [0.00-1.00]
+RECOMMENDATIONS: [Actionable recommendations, one per line]
+NEXT_STEPS: [Logical next steps, one per line]
+
+Your synthesis:`;
+  }
+  getStyleInstructions(style) {
+    const instructions = {
+      analytical: "Use logical, step-by-step analysis. Break down complex problems into components. Focus on cause-and-effect relationships.",
+      systematic: "Follow a methodical, structured approach. Use frameworks and established methodologies. Ensure completeness and consistency.",
+      creative: "Think outside the box. Consider unconventional approaches. Generate innovative solutions and alternatives.",
+      scientific: "Use hypothesis-driven investigation. Seek evidence and test assumptions. Apply scientific method principles.",
+      critical: "Question assumptions and evaluate evidence critically. Consider biases and alternative perspectives. Challenge conventional thinking.",
+      strategic: "Think long-term and high-level. Consider broader implications and context. Focus on strategic planning and positioning.",
+      intuitive: "Use pattern recognition and experience-based insights. Trust experienced judgment while validating with evidence.",
+      collaborative: "Consider multiple perspectives and stakeholder viewpoints. Seek consensus and collaborative solutions."
+    };
+    return instructions[style] || instructions.analytical;
+  }
+  formatPreviousThoughts(thoughts) {
+    if (thoughts.length === 0) {
+      return "No previous thoughts yet.";
+    }
+    return thoughts.map((thought) => {
+      const revisionNote = thought.isRevision ? " (REVISION)" : "";
+      const branchNote = thought.branchId ? " (BRANCH)" : "";
+      return `${thought.number}. ${thought.content} [Confidence: ${thought.confidence.toFixed(2)}]${revisionNote}${branchNote}`;
+    }).join(`
+
+`);
+  }
+  formatHypotheses(hypotheses) {
+    if (hypotheses.length === 0) {
+      return "No hypotheses tested yet.";
+    }
+    return hypotheses.map((hyp) => {
+      const status = hyp.tested ? ` - ${hyp.result?.toUpperCase()}` : " - NOT TESTED";
+      return `- ${hyp.statement} [Confidence: ${hyp.confidence.toFixed(2)}]${status}`;
+    }).join(`
+`);
+  }
+  formatContext(context) {
+    const parts = [];
+    if (context.domain)
+      parts.push(`**Domain:** ${context.domain}`);
+    if (context.background)
+      parts.push(`**Background:** ${context.background}`);
+    if (context.constraints?.length)
+      parts.push(`**Constraints:** ${context.constraints.join(", ")}`);
+    if (context.requirements?.length)
+      parts.push(`**Requirements:** ${context.requirements.join(", ")}`);
+    if (context.timeframe)
+      parts.push(`**Timeframe:** ${context.timeframe}`);
+    return parts.length > 0 ? parts.join(`
+`) + `
+` : "";
+  }
+  extractConfidence(content) {
+    const confidenceMatch = content.match(/\[Confidence:\s*(\d*\.?\d+)\]/i);
+    if (confidenceMatch && confidenceMatch[1]) {
+      const confidence = parseFloat(confidenceMatch[1]);
+      return Math.min(Math.max(confidence, 0), 1);
+    }
+    return null;
+  }
+  estimateConfidence(content, previousThoughts) {
+    let confidence = 0.5;
+    if (content.length > 200)
+      confidence += 0.1;
+    if (content.length > 500)
+      confidence += 0.1;
+    if (content.includes("specifically") || content.includes("evidence") || content.includes("data")) {
+      confidence += 0.1;
+    }
+    if (previousThoughts.length > 0 && (content.includes("previous") || content.includes("building on"))) {
+      confidence += 0.1;
+    }
+    if (content.includes("might") || content.includes("possibly") || content.includes("unclear")) {
+      confidence -= 0.1;
+    }
+    return Math.min(Math.max(confidence, 0.1), 0.9);
+  }
+  cleanThoughtContent(content) {
+    return content.replace(/\[Confidence:\s*\d*\.?\d+\]/gi, "").replace(/^Your thought #\d+:\s*/i, "").replace(/^Thought #?\d+:?\s*/i, "").trim();
+  }
+  parseHypothesisResponse(content) {
+    const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => line);
+    let statement = "";
+    let confidence = 0.5;
+    const evidence = [];
+    for (const line of lines) {
+      if (line.startsWith("HYPOTHESIS:")) {
+        statement = line.replace("HYPOTHESIS:", "").trim();
+      } else if (line.startsWith("CONFIDENCE:")) {
+        const confMatch = line.match(/(\d*\.?\d+)/);
+        if (confMatch && confMatch[1]) {
+          confidence = Math.min(Math.max(parseFloat(confMatch[1]), 0), 1);
+        }
+      } else if (line.startsWith("EVIDENCE:")) {
+        continue;
+      } else if (line.startsWith("- ") || line.startsWith("* ")) {
+        evidence.push(line.replace(/^[-*]\s*/, ""));
+      }
+    }
+    return {
+      statement: statement || "Generated hypothesis",
+      confidence,
+      evidence
+    };
+  }
+  parseHypothesisTestResponse(content) {
+    const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => line);
+    let result = "inconclusive";
+    let reasoning = "";
+    const evidence = [];
+    for (const line of lines) {
+      if (line.startsWith("RESULT:")) {
+        const resultText = line.replace("RESULT:", "").trim().toLowerCase();
+        if (resultText.includes("confirmed"))
+          result = "confirmed";
+        else if (resultText.includes("rejected"))
+          result = "rejected";
+        else
+          result = "inconclusive";
+      } else if (line.startsWith("REASONING:")) {
+        reasoning = line.replace("REASONING:", "").trim();
+      } else if (line.startsWith("EVIDENCE:")) {
+        continue;
+      } else if (line.startsWith("- ") || line.startsWith("* ")) {
+        evidence.push(line.replace(/^[-*]\s*/, ""));
+      }
+    }
+    return { result, evidence, reasoning };
+  }
+  parseSynthesisResponse(content) {
+    const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => line);
+    let analysis = "";
+    let confidence = 0.7;
+    const recommendations = [];
+    const nextSteps = [];
+    let currentSection = "";
+    for (const line of lines) {
+      if (line.startsWith("ANALYSIS:")) {
+        currentSection = "analysis";
+        analysis = line.replace("ANALYSIS:", "").trim();
+      } else if (line.startsWith("CONFIDENCE:")) {
+        const confMatch = line.match(/(\d*\.?\d+)/);
+        if (confMatch && confMatch[1]) {
+          confidence = Math.min(Math.max(parseFloat(confMatch[1]), 0), 1);
+        }
+      } else if (line.startsWith("RECOMMENDATIONS:")) {
+        currentSection = "recommendations";
+      } else if (line.startsWith("NEXT_STEPS:")) {
+        currentSection = "nextSteps";
+      } else if (line.startsWith("- ") || line.startsWith("* ")) {
+        const item = line.replace(/^[-*]\s*/, "");
+        if (currentSection === "recommendations") {
+          recommendations.push(item);
+        } else if (currentSection === "nextSteps") {
+          nextSteps.push(item);
+        }
+      } else if (currentSection === "analysis" && line) {
+        analysis += (analysis ? " " : "") + line;
+      }
+    }
+    return {
+      analysis: analysis || "Analysis completed",
+      confidence,
+      recommendations,
+      nextSteps
+    };
+  }
+}
+
+// src/tools/brain/processors/sequential-thinking.ts
+class SequentialThinkingProcessor {
+  geminiClient;
+  reasoningEngine;
+  constructor(geminiClient) {
+    this.geminiClient = geminiClient;
+    this.reasoningEngine = new ReasoningEngine(geminiClient);
+  }
+  async process(input) {
+    const startTime = Date.now();
+    try {
+      logger2.info(`Starting sequential thinking for: ${input.problem.substring(0, 100)}...`);
+      const thoughtManager = new ThoughtManager(input.problem, input.thinkingStyle || "analytical", input.context, input.options);
+      await this.generateInitialThoughts(thoughtManager, input);
+      await this.continueThinking(thoughtManager, input);
+      if (input.options?.requireEvidence) {
+        await this.generateHypotheses(thoughtManager, input);
+      }
+      const synthesis = await this.synthesizeFinalAnalysis(thoughtManager, input);
+      const finalProcess = thoughtManager.finalize();
+      const processingTime = Date.now() - startTime;
+      return {
+        thoughtProcess: finalProcess,
+        finalAnswer: synthesis.analysis,
+        confidence: synthesis.confidence,
+        reasoning: this.buildReasoningChain(finalProcess),
+        recommendations: synthesis.recommendations,
+        nextSteps: synthesis.nextSteps,
+        processingInfo: {
+          totalThoughts: finalProcess.thoughts.length,
+          processingTime,
+          revisionsUsed: finalProcess.metadata.revisionsCount,
+          branchesExplored: finalProcess.metadata.branchesCount,
+          hypothesesTested: finalProcess.hypotheses.filter((h) => h.tested).length,
+          finalConfidence: synthesis.confidence
+        }
+      };
+    } catch (error) {
+      logger2.error("Sequential thinking processing failed:", error);
+      throw new APIError(`Sequential thinking failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async generateInitialThoughts(thoughtManager, input) {
+    logger2.debug(`Generating ${input.initialThoughts} initial thoughts`);
+    for (let i = 1;i <= (input.initialThoughts || 5); i++) {
+      try {
+        const thoughtResult = await this.reasoningEngine.generateThought(input.problem, thoughtManager.getThoughts(), input.thinkingStyle || "analytical", i, input.context);
+        thoughtManager.addThought(thoughtResult.content, thoughtResult.confidence, {
+          tags: ["initial"]
+        });
+        await this.pause(100);
+      } catch (error) {
+        logger2.warn(`Failed to generate initial thought ${i}:`, error);
+      }
+    }
+  }
+  async continueThinking(thoughtManager, input) {
+    const maxThoughts = input.options?.maxThoughts || 10;
+    const timeLimit = (input.options?.timeLimit || 60) * 1000;
+    const startTime = Date.now();
+    while (thoughtManager.needsMoreThoughts() && thoughtManager.getProcess().thoughts.length < maxThoughts && Date.now() - startTime < timeLimit) {
+      try {
+        const currentThoughts = thoughtManager.getThoughts();
+        const nextThoughtNumber = currentThoughts.length + 1;
+        const shouldRevise = this.shouldReviseThought(currentThoughts, input.options);
+        if (shouldRevise && input.options?.allowRevision) {
+          await this.performRevision(thoughtManager, input);
+        } else {
+          const thoughtResult = await this.reasoningEngine.generateThought(input.problem, currentThoughts, input.thinkingStyle || "analytical", nextThoughtNumber, input.context);
+          thoughtManager.addThought(thoughtResult.content, thoughtResult.confidence, {
+            tags: ["continuation"]
+          });
+        }
+        await this.pause(200);
+      } catch (error) {
+        logger2.warn("Failed to continue thinking:", error);
+        break;
+      }
+    }
+    logger2.info(`Completed thinking with ${thoughtManager.getProcess().thoughts.length} thoughts`);
+  }
+  shouldReviseThought(thoughts, options) {
+    if (!options?.allowRevision)
+      return false;
+    if (thoughts.length < 3)
+      return false;
+    const lowConfidenceThoughts = thoughts.filter((t) => t.confidence < 0.6);
+    const hasRecentRevision = thoughts.slice(-2).some((t) => t.isRevision);
+    return lowConfidenceThoughts.length > 0 && !hasRecentRevision;
+  }
+  async performRevision(thoughtManager, input) {
+    const thoughts = thoughtManager.getThoughts();
+    const candidatesForRevision = thoughts.filter((t) => !t.isRevision && t.confidence < 0.7).sort((a, b) => a.confidence - b.confidence);
+    if (candidatesForRevision.length === 0)
+      return;
+    const toRevise = candidatesForRevision[0];
+    try {
+      const revisionPrompt = this.buildRevisionPrompt(toRevise, thoughts, input);
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(revisionPrompt);
+      const content = response.response.text();
+      if (content) {
+        thoughtManager.addThought(content, Math.min((toRevise?.confidence ?? 0.5) + 0.2, 1), {
+          isRevision: true,
+          revisesThought: toRevise?.number,
+          tags: ["revision"]
+        });
+        logger2.debug(`Revised thought ${toRevise?.number}`);
+      }
+    } catch (error) {
+      logger2.warn(`Failed to revise thought ${toRevise?.number}:`, error);
+    }
+  }
+  buildRevisionPrompt(originalThought, allThoughts, input) {
+    return `You are revising and improving a previous thought in a sequential thinking process.
+
+**Original Problem:**
+${input.problem}
+
+**Original Thought #${originalThought?.number} (Confidence: ${originalThought?.confidence.toFixed(2)}):**
+${originalThought?.content}
+
+**Context from other thoughts:**
+${allThoughts.filter((t) => t.number !== originalThought?.number).map((t) => `${t.number}. ${t.content}`).join(`
+`)}
+
+**Task:**
+Revise and improve the original thought. Make it more specific, accurate, and insightful.
+
+**Focus on:**
+- Adding more specific details or evidence
+- Correcting any logical issues
+- Connecting better with other thoughts
+- Increasing clarity and actionability
+
+**Revised thought:`;
+  }
+  async generateHypotheses(thoughtManager, input) {
+    try {
+      const hypothesisResult = await this.reasoningEngine.generateHypothesis(input.problem, thoughtManager.getThoughts(), input.thinkingStyle || "analytical");
+      const hypothesis = thoughtManager.addHypothesis(hypothesisResult.statement, hypothesisResult.evidence, [], hypothesisResult.confidence);
+      const testResult = await this.reasoningEngine.testHypothesis(hypothesis, thoughtManager.getThoughts());
+      thoughtManager.testHypothesis(hypothesis.id, testResult.result, testResult.evidence);
+      logger2.info(`Generated and tested hypothesis: ${testResult.result}`);
+    } catch (error) {
+      logger2.warn("Failed to generate hypotheses:", error);
+    }
+  }
+  async synthesizeFinalAnalysis(thoughtManager, input) {
+    try {
+      return await this.reasoningEngine.synthesizeAnalysis(input.problem, thoughtManager.getThoughts(), thoughtManager.getProcess().hypotheses, input.thinkingStyle || "analytical", input.context);
+    } catch (error) {
+      logger2.error("Failed to synthesize analysis:", error);
+      const thoughts = thoughtManager.getThoughts();
+      const avgConfidence = thoughts.reduce((sum, t) => sum + t.confidence, 0) / thoughts.length;
+      return {
+        analysis: `Based on ${thoughts.length} thoughts, the analysis suggests multiple approaches to the problem. Key insights include the main themes identified through ${input.thinkingStyle} thinking.`,
+        confidence: avgConfidence,
+        recommendations: ["Review the thought process", "Consider implementation"],
+        nextSteps: ["Validate assumptions", "Plan next phase"]
+      };
+    }
+  }
+  buildReasoningChain(process3) {
+    const thoughts = process3.thoughts;
+    if (thoughts.length === 0)
+      return "No reasoning chain available.";
+    const chain = thoughts.map((thought) => {
+      const prefix = thought.isRevision ? "↻ " : "→ ";
+      const confidence = `[${(thought.confidence * 100).toFixed(0)}%]`;
+      return `${prefix}${thought.content} ${confidence}`;
+    }).join(`
+
+`);
+    const summary = `
+Reasoning Summary:
+- Total thoughts: ${thoughts.length}
+- Revisions: ${process3.metadata.revisionsCount}
+- Average confidence: ${(thoughts.reduce((sum, t) => sum + t.confidence, 0) / thoughts.length * 100).toFixed(0)}%`;
+    return chain + summary;
+  }
+  async pause(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+// src/tools/brain/processors/analytical-reasoning.ts
+class AnalyticalReasoningProcessor {
+  geminiClient;
+  reasoningEngine;
+  constructor(geminiClient) {
+    this.geminiClient = geminiClient;
+    this.reasoningEngine = new ReasoningEngine(geminiClient);
+  }
+  async process(input) {
+    const startTime = Date.now();
+    try {
+      logger2.info(`Starting analytical reasoning for: ${input.subject.substring(0, 100)}...`);
+      const thoughtManager = new ThoughtManager(input.subject, input.thinkingStyle, input.context, {
+        ...input.options,
+        enableBranching: input.considerAlternatives
+      });
+      await this.performStructuredAnalysis(thoughtManager, input);
+      if (input.considerAlternatives) {
+        await this.exploreAlternatives(thoughtManager, input);
+      }
+      if (input.trackAssumptions) {
+        await this.analyzeAssumptions(thoughtManager, input);
+      }
+      const synthesis = await this.synthesizeAnalysis(thoughtManager, input);
+      const keyFindings = await this.extractKeyFindings(thoughtManager, input);
+      const evidenceQuality = this.assessEvidenceQuality(thoughtManager.getThoughts());
+      const finalProcess = thoughtManager.finalize();
+      const processingTime = Date.now() - startTime;
+      return {
+        thoughtProcess: finalProcess,
+        finalAnswer: synthesis.analysis,
+        confidence: synthesis.confidence,
+        reasoning: this.buildAnalyticalReasoning(finalProcess),
+        recommendations: synthesis.recommendations,
+        nextSteps: synthesis.nextSteps,
+        keyFindings,
+        assumptions: await this.extractAssumptions(thoughtManager.getThoughts()),
+        evidenceQuality,
+        riskFactors: await this.identifyRiskFactors(thoughtManager, input),
+        opportunities: await this.identifyOpportunities(thoughtManager, input),
+        processingInfo: {
+          totalThoughts: finalProcess.thoughts.length,
+          processingTime,
+          revisionsUsed: finalProcess.metadata.revisionsCount,
+          branchesExplored: finalProcess.metadata.branchesCount,
+          hypothesesTested: finalProcess.hypotheses.filter((h) => h.tested).length,
+          finalConfidence: synthesis.confidence
+        }
+      };
+    } catch (error) {
+      logger2.error("Analytical reasoning processing failed:", error);
+      throw new APIError(`Analytical reasoning failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async performStructuredAnalysis(thoughtManager, input) {
+    const analysisSteps = this.getAnalysisSteps(input.analysisDepth ?? "detailed", input.focusAreas);
+    for (let i = 0;i < analysisSteps.length; i++) {
+      const step = analysisSteps[i];
+      if (!step)
+        continue;
+      try {
+        const thoughtResult = await this.generateAnalyticalThought(input.subject, step, thoughtManager.getThoughts(), input.thinkingStyle ?? "analytical", input.context);
+        if (step) {
+          thoughtManager.addThought(thoughtResult.content, thoughtResult.confidence, {
+            tags: ["analytical", step.category]
+          });
+        }
+        await this.pause(150);
+      } catch (error) {
+        logger2.warn(`Failed to complete analysis step "${step?.name}":`, error);
+      }
+    }
+  }
+  async exploreAlternatives(thoughtManager, input) {
+    try {
+      const alternativeBranch = thoughtManager.createBranch(thoughtManager.getProcess().currentThought, "Alternative Perspectives");
+      const alternatives = await this.generateAlternativePerspectives(input.subject, thoughtManager.getThoughts(), input.context);
+      for (const alternative of alternatives) {
+        const thoughtResult = await this.generateAnalyticalThought(input.subject, {
+          name: "Alternative Perspective",
+          prompt: alternative.prompt,
+          category: "alternative"
+        }, thoughtManager.getThoughts(), "critical", input.context);
+        thoughtManager.addThought(thoughtResult.content, thoughtResult.confidence, {
+          branchId: alternativeBranch.id,
+          branchFromThought: alternativeBranch.fromThought,
+          tags: ["alternative", alternative.type]
+        });
+        await this.pause(200);
+      }
+    } catch (error) {
+      logger2.warn("Failed to explore alternatives:", error);
+    }
+  }
+  async analyzeAssumptions(thoughtManager, input) {
+    try {
+      const assumptionAnalysisPrompt = this.buildAssumptionAnalysisPrompt(input.subject, thoughtManager.getThoughts());
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(assumptionAnalysisPrompt);
+      const content = response.response.text();
+      if (content) {
+        thoughtManager.addThought(content, 0.8, {
+          tags: ["assumptions", "meta-analysis"]
+        });
+      }
+    } catch (error) {
+      logger2.warn("Failed to analyze assumptions:", error);
+    }
+  }
+  getAnalysisSteps(depth, focusAreas) {
+    const baseSteps = [
+      {
+        name: "Problem Definition",
+        prompt: "Clearly define and scope the subject for analysis",
+        category: "definition"
+      },
+      {
+        name: "Context Analysis",
+        prompt: "Analyze the broader context and environment",
+        category: "context"
+      },
+      {
+        name: "Component Breakdown",
+        prompt: "Break down the subject into key components",
+        category: "breakdown"
+      }
+    ];
+    const detailedSteps = [
+      {
+        name: "Stakeholder Analysis",
+        prompt: "Identify and analyze key stakeholders and their interests",
+        category: "stakeholders"
+      },
+      {
+        name: "Constraint Analysis",
+        prompt: "Identify constraints, limitations, and dependencies",
+        category: "constraints"
+      },
+      {
+        name: "Impact Assessment",
+        prompt: "Assess potential impacts and consequences",
+        category: "impact"
+      }
+    ];
+    const comprehensiveSteps = [
+      {
+        name: "Trend Analysis",
+        prompt: "Analyze relevant trends and patterns",
+        category: "trends"
+      },
+      {
+        name: "Risk Analysis",
+        prompt: "Identify and evaluate potential risks",
+        category: "risks"
+      },
+      {
+        name: "Opportunity Analysis",
+        prompt: "Identify potential opportunities and benefits",
+        category: "opportunities"
+      },
+      {
+        name: "Competitive Analysis",
+        prompt: "Analyze competitive landscape and positioning",
+        category: "competition"
+      }
+    ];
+    let steps = [...baseSteps];
+    if (depth === "detailed" || depth === "comprehensive") {
+      steps.push(...detailedSteps);
+    }
+    if (depth === "comprehensive") {
+      steps.push(...comprehensiveSteps);
+    }
+    if (focusAreas && focusAreas.length > 0) {
+      for (const area of focusAreas) {
+        steps.push({
+          name: `${area} Focus`,
+          prompt: `Provide detailed analysis specifically focused on ${area}`,
+          category: "focus"
+        });
+      }
+    }
+    return steps;
+  }
+  async generateAnalyticalThought(subject, step, previousThoughts, thinkingStyle, context) {
+    const prompt = this.buildStepPrompt(subject, step, previousThoughts, thinkingStyle, context);
+    const model = this.geminiClient.getModel("detailed");
+    const response = await model.generateContent(prompt);
+    const result = response.response;
+    const content = result.text();
+    if (!content) {
+      throw new APIError(`No content generated for analysis step: ${step.name}`);
+    }
+    const confidence = this.estimateStepConfidence(content, step.category);
+    return {
+      content: this.cleanStepContent(content, step.name),
+      confidence
+    };
+  }
+  buildStepPrompt(subject, step, previousThoughts, thinkingStyle, context) {
+    const contextInfo = context ? this.formatContext(context) : "";
+    const thoughtsContext = this.formatPreviousThoughts(previousThoughts);
+    return `You are performing ${step.name} as part of a comprehensive analytical process.
+
+**Subject for Analysis:**
+${subject}
+
+${contextInfo}
+
+**Analysis Step:** ${step.name}
+**Objective:** ${step.prompt}
+
+**Previous Analysis:**
+${thoughtsContext}
+
+**Instructions:**
+- Use ${thinkingStyle} thinking approach
+- Be specific and evidence-based
+- Build upon previous analysis without repeating
+- Identify key insights and patterns
+- Consider multiple perspectives
+- Provide actionable insights
+
+**Your ${step.name} analysis:`;
+  }
+  async generateAlternativePerspectives(subject, thoughts, context) {
+    const alternatives = [
+      {
+        type: "contrarian",
+        prompt: "Challenge the main assumptions and provide a contrarian perspective"
+      },
+      {
+        type: "optimistic",
+        prompt: "Analyze from an optimistic viewpoint, focusing on positive outcomes"
+      },
+      {
+        type: "pessimistic",
+        prompt: "Consider potential negative outcomes and worst-case scenarios"
+      },
+      {
+        type: "outsider",
+        prompt: "Analyze from an external or outsider perspective"
+      }
+    ];
+    return alternatives;
+  }
+  buildAssumptionAnalysisPrompt(subject, thoughts) {
+    const thoughtsText = thoughts.map((t) => t.content).join(`
+
+`);
+    return `Analyze the assumptions made in the previous analysis.
+
+**Subject:** ${subject}
+
+**Analysis so far:**
+${thoughtsText}
+
+**Task:** Identify and evaluate the key assumptions underlying this analysis.
+
+**Focus on:**
+- Explicit and implicit assumptions
+- Validity and strength of each assumption
+- Potential risks if assumptions are wrong
+- Evidence supporting or contradicting assumptions
+- Alternative assumptions that could be considered
+
+**Your assumption analysis:`;
+  }
+  async synthesizeAnalysis(thoughtManager, input) {
+    return await this.reasoningEngine.synthesizeAnalysis(input.subject, thoughtManager.getThoughts(), thoughtManager.getProcess().hypotheses, input.thinkingStyle ?? "analytical", input.context);
+  }
+  async extractKeyFindings(thoughtManager, input) {
+    try {
+      const findings = [];
+      const thoughts = thoughtManager.getThoughts();
+      const highConfidenceThoughts = thoughts.filter((t) => t.confidence > 0.7);
+      for (const thought of highConfidenceThoughts) {
+        if (thought.content.includes("finding:") || thought.content.includes("insight:")) {
+          findings.push(thought.content);
+        }
+      }
+      const categories = ["definition", "context", "breakdown", "stakeholders", "constraints"];
+      for (const category of categories) {
+        const categoryThoughts = thoughts.filter((t) => t.tags?.includes(category));
+        if (categoryThoughts.length > 0) {
+          const bestThought = categoryThoughts.sort((a, b) => b.confidence - a.confidence)[0];
+          if (bestThought) {
+            findings.push(`${category}: ${bestThought.content.substring(0, 200)}...`);
+          }
+        }
+      }
+      return findings.slice(0, 10);
+    } catch (error) {
+      logger2.warn("Failed to extract key findings:", error);
+      return ["Analysis completed with multiple insights identified"];
+    }
+  }
+  async extractAssumptions(thoughts) {
+    const assumptions = [];
+    for (const thought of thoughts) {
+      if (thought.tags?.includes("assumptions")) {
+        const lines = thought.content.split(`
+`);
+        for (const line of lines) {
+          if (line.includes("assume") || line.includes("given that") || line.includes("if we consider")) {
+            assumptions.push(line.trim());
+          }
+        }
+      }
+    }
+    return assumptions.slice(0, 8);
+  }
+  assessEvidenceQuality(thoughts) {
+    const evidenceIndicators = {
+      strong: ["data shows", "research indicates", "proven", "demonstrated", "evidence suggests"],
+      moderate: ["likely", "probably", "indicates", "suggests", "appears"],
+      weak: ["might", "could", "possibly", "perhaps", "speculation"]
+    };
+    let strongCount = 0;
+    let moderateCount = 0;
+    let weakCount = 0;
+    for (const thought of thoughts) {
+      const content = thought.content.toLowerCase();
+      for (const indicator of evidenceIndicators.strong) {
+        if (content.includes(indicator))
+          strongCount++;
+      }
+      for (const indicator of evidenceIndicators.moderate) {
+        if (content.includes(indicator))
+          moderateCount++;
+      }
+      for (const indicator of evidenceIndicators.weak) {
+        if (content.includes(indicator))
+          weakCount++;
+      }
+    }
+    const totalIndicators = strongCount + moderateCount + weakCount;
+    if (totalIndicators === 0)
+      return "insufficient";
+    const strongRatio = strongCount / totalIndicators;
+    const moderateRatio = moderateCount / totalIndicators;
+    if (strongRatio > 0.6)
+      return "strong";
+    if (strongRatio + moderateRatio > 0.7)
+      return "moderate";
+    return "weak";
+  }
+  async identifyRiskFactors(thoughtManager, input) {
+    const riskThoughts = thoughtManager.getThoughts().filter((t) => t.tags?.includes("risks") || t.content.toLowerCase().includes("risk") || t.content.toLowerCase().includes("threat") || t.content.toLowerCase().includes("danger"));
+    return riskThoughts.map((t) => this.extractRiskStatements(t.content)).flat().slice(0, 5);
+  }
+  async identifyOpportunities(thoughtManager, input) {
+    const opportunityThoughts = thoughtManager.getThoughts().filter((t) => t.tags?.includes("opportunities") || t.content.toLowerCase().includes("opportunity") || t.content.toLowerCase().includes("benefit") || t.content.toLowerCase().includes("advantage"));
+    return opportunityThoughts.map((t) => this.extractOpportunityStatements(t.content)).flat().slice(0, 5);
+  }
+  extractRiskStatements(content) {
+    const riskKeywords = ["risk of", "threat of", "danger of", "potential for"];
+    const statements = [];
+    for (const keyword of riskKeywords) {
+      const index = content.toLowerCase().indexOf(keyword);
+      if (index !== -1) {
+        const start = Math.max(0, index - 50);
+        const end = Math.min(content.length, index + 150);
+        statements.push(content.substring(start, end).trim());
+      }
+    }
+    return statements;
+  }
+  extractOpportunityStatements(content) {
+    const opportunityKeywords = ["opportunity to", "benefit of", "advantage of", "potential to"];
+    const statements = [];
+    for (const keyword of opportunityKeywords) {
+      const index = content.toLowerCase().indexOf(keyword);
+      if (index !== -1) {
+        const start = Math.max(0, index - 50);
+        const end = Math.min(content.length, index + 150);
+        statements.push(content.substring(start, end).trim());
+      }
+    }
+    return statements;
+  }
+  buildAnalyticalReasoning(process3) {
+    const thoughts = process3.thoughts;
+    const categories = this.groupThoughtsByCategory(thoughts);
+    let reasoning = `Analytical Reasoning Process:
+
+`;
+    for (const [category, categoryThoughts] of Object.entries(categories)) {
+      reasoning += `${category.toUpperCase()}:
+`;
+      for (const thought of categoryThoughts) {
+        reasoning += `• ${thought.content.substring(0, 200)}...
+`;
+      }
+      reasoning += `
+`;
+    }
+    return reasoning;
+  }
+  groupThoughtsByCategory(thoughts) {
+    const categories = {};
+    for (const thought of thoughts) {
+      const category = thought.tags?.[1] || "general";
+      if (!categories[category]) {
+        categories[category] = [];
+      }
+      categories[category].push(thought);
+    }
+    return categories;
+  }
+  formatContext(context) {
+    return context ? `**Context:** ${JSON.stringify(context)}
+` : "";
+  }
+  formatPreviousThoughts(thoughts) {
+    if (thoughts.length === 0)
+      return "No previous analysis yet.";
+    return thoughts.map((t) => `${t.number}. ${t.content}`).join(`
+
+`);
+  }
+  estimateStepConfidence(content, category) {
+    let confidence = 0.7;
+    if (category === "definition" && content.length > 100)
+      confidence += 0.1;
+    if (category === "breakdown" && content.includes("component"))
+      confidence += 0.1;
+    if (category === "evidence" && content.includes("data"))
+      confidence += 0.2;
+    return Math.min(confidence, 0.95);
+  }
+  cleanStepContent(content, stepName) {
+    return content.replace(new RegExp(`^Your ${stepName} analysis:?\\s*`, "i"), "").replace(/^\s*[\-•]\s*/, "").trim();
+  }
+  async pause(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+// src/tools/brain/processors/problem-solver.ts
+class ProblemSolverProcessor {
+  geminiClient;
+  reasoningEngine;
+  constructor(geminiClient) {
+    this.geminiClient = geminiClient;
+    this.reasoningEngine = new ReasoningEngine(geminiClient);
+  }
+  async process(input) {
+    const startTime = Date.now();
+    try {
+      logger2.info(`Starting problem solving for: ${input.problemStatement.substring(0, 100)}...`);
+      const thoughtManager = new ThoughtManager(input.problemStatement, this.mapSolutionApproachToThinkingStyle(input.solutionApproach ?? "systematic"), input.context, {
+        ...input.options,
+        requireEvidence: input.verifyHypotheses
+      });
+      await this.defineProblem(thoughtManager, input);
+      await this.generateSolutions(thoughtManager, input);
+      if (input.verifyHypotheses) {
+        await this.testSolutionHypotheses(thoughtManager, input);
+      }
+      const solution = await this.evaluateAndSelectSolution(thoughtManager, input);
+      const implementationPlan = await this.generateImplementationPlan(thoughtManager, input, solution);
+      const finalProcess = thoughtManager.finalize();
+      const processingTime = Date.now() - startTime;
+      return {
+        thoughtProcess: finalProcess,
+        finalAnswer: solution.statement,
+        confidence: solution.confidence,
+        reasoning: this.buildSolutionReasoning(finalProcess),
+        recommendations: solution.recommendations,
+        nextSteps: implementationPlan.steps,
+        proposedSolution: solution.statement,
+        implementationSteps: implementationPlan.steps,
+        potentialObstacles: implementationPlan.obstacles,
+        successCriteria: implementationPlan.successCriteria,
+        testPlan: implementationPlan.testPlan,
+        fallbackOptions: solution.alternatives,
+        processingInfo: {
+          totalThoughts: finalProcess.thoughts.length,
+          processingTime,
+          revisionsUsed: finalProcess.metadata.revisionsCount,
+          branchesExplored: finalProcess.metadata.branchesCount,
+          hypothesesTested: finalProcess.hypotheses.filter((h) => h.tested).length,
+          finalConfidence: solution.confidence
+        }
+      };
+    } catch (error) {
+      logger2.error("Problem solving processing failed:", error);
+      throw new APIError(`Problem solving failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async defineProblem(thoughtManager, input) {
+    const definitionPrompt = this.buildProblemDefinitionPrompt(input);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(definitionPrompt);
+      const content = response.response.text();
+      if (content) {
+        thoughtManager.addThought(content, 0.9, {
+          tags: ["problem_definition", "foundation"]
+        });
+      }
+    } catch (error) {
+      logger2.warn("Failed to define problem:", error);
+    }
+  }
+  async generateSolutions(thoughtManager, input) {
+    const maxIterations = Math.min(input.maxIterations ?? 5, 10);
+    for (let i = 1;i <= maxIterations; i++) {
+      try {
+        const solutionPrompt = this.buildSolutionGenerationPrompt(input, thoughtManager.getThoughts(), i);
+        const model = this.geminiClient.getModel("detailed");
+        const response = await model.generateContent(solutionPrompt);
+        const content = response.response.text();
+        if (content) {
+          const confidence = this.estimateSolutionConfidence(content, i, maxIterations);
+          thoughtManager.addThought(content, confidence, {
+            tags: ["solution_candidate", `iteration_${i}`]
+          });
+          if (input.verifyHypotheses) {
+            await this.generateSolutionHypothesis(thoughtManager, content, i);
+          }
+        }
+        await this.pause(200);
+      } catch (error) {
+        logger2.warn(`Failed to generate solution iteration ${i}:`, error);
+      }
+    }
+  }
+  async generateSolutionHypothesis(thoughtManager, solutionContent, iteration) {
+    try {
+      const hypothesis = thoughtManager.addHypothesis(`Solution ${iteration} will effectively address the problem`, [solutionContent], [], 0.6);
+      const testResult = await this.reasoningEngine.testHypothesis(hypothesis, thoughtManager.getThoughts());
+      thoughtManager.testHypothesis(hypothesis.id, testResult.result, testResult.evidence);
+    } catch (error) {
+      logger2.warn(`Failed to generate hypothesis for solution ${iteration}:`, error);
+    }
+  }
+  async testSolutionHypotheses(thoughtManager, input) {
+    const untested = thoughtManager.getActiveHypotheses();
+    for (const hypothesis of untested) {
+      try {
+        const testResult = await this.reasoningEngine.testHypothesis(hypothesis, thoughtManager.getThoughts(), `Testing solution viability against constraints: ${input.constraints?.join(", ")}`);
+        thoughtManager.testHypothesis(hypothesis.id, testResult.result, testResult.evidence);
+        await this.pause(150);
+      } catch (error) {
+        logger2.warn(`Failed to test hypothesis ${hypothesis.id}:`, error);
+      }
+    }
+  }
+  async evaluateAndSelectSolution(thoughtManager, input) {
+    const evaluationPrompt = this.buildSolutionEvaluationPrompt(input, thoughtManager);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(evaluationPrompt);
+      const content = response.response.text();
+      if (!content) {
+        throw new Error("No solution evaluation generated");
+      }
+      const evaluation = this.parseSolutionEvaluation(content);
+      thoughtManager.addThought(`Selected solution: ${evaluation.statement}`, evaluation.confidence, { tags: ["final_solution", "decision"] });
+      return evaluation;
+    } catch (error) {
+      logger2.error("Failed to evaluate solutions:", error);
+      const solutions = thoughtManager.getThoughts().filter((t) => t.tags?.includes("solution_candidate"));
+      const bestSolution = solutions.sort((a, b) => b.confidence - a.confidence)[0];
+      return {
+        statement: bestSolution?.content || "Unable to determine optimal solution",
+        confidence: bestSolution?.confidence || 0.5,
+        recommendations: ["Review solution candidates", "Consider additional approaches"],
+        alternatives: solutions.slice(1, 4).map((s) => s.content)
+      };
+    }
+  }
+  async generateImplementationPlan(thoughtManager, input, solution) {
+    const implementationPrompt = this.buildImplementationPrompt(input, solution);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(implementationPrompt);
+      const content = response.response.text();
+      if (!content) {
+        throw new Error("No implementation plan generated");
+      }
+      return this.parseImplementationPlan(content);
+    } catch (error) {
+      logger2.error("Failed to generate implementation plan:", error);
+      return {
+        steps: ["Plan implementation details", "Execute solution", "Monitor results"],
+        obstacles: ["Resource constraints", "Technical challenges"],
+        successCriteria: ["Problem is resolved", "Requirements are met"],
+        testPlan: ["Validate solution", "Monitor outcomes"]
+      };
+    }
+  }
+  buildProblemDefinitionPrompt(input) {
+    const constraintsText = input.constraints?.length ? `
+**Constraints:** ${input.constraints.join(", ")}` : "";
+    const requirementsText = input.requirements?.length ? `
+**Requirements:** ${input.requirements.join(", ")}` : "";
+    return `You are defining a problem for systematic solution development.
+
+**Problem Statement:**
+${input.problemStatement}
+${constraintsText}
+${requirementsText}
+
+**Context:**
+${input.context ? JSON.stringify(input.context) : "No additional context provided"}
+
+**Task:**
+Provide a clear, comprehensive problem definition that includes:
+1. Core problem description
+2. Scope and boundaries
+3. Key stakeholders affected
+4. Success criteria
+5. Critical factors to consider
+
+**Your problem definition:`;
+  }
+  buildSolutionGenerationPrompt(input, previousThoughts, iteration) {
+    const previousSolutions = previousThoughts.filter((t) => t.tags?.includes("solution_candidate")).map((t) => `- ${t.content}`).join(`
+`);
+    const approach = this.getSolutionApproachInstructions(input.solutionApproach ?? "systematic");
+    return `Generate solution candidate #${iteration} for the problem.
+
+**Problem:**
+${input.problemStatement}
+
+**Approach:** ${input.solutionApproach ?? "systematic"}
+${approach}
+
+**Constraints:** ${input.constraints?.join(", ") || "None specified"}
+**Requirements:** ${input.requirements?.join(", ") || "None specified"}
+
+**Previous solution candidates:**
+${previousSolutions || "None yet"}
+
+**Task:**
+Generate a ${iteration === 1 ? "comprehensive" : "alternative"} solution that:
+- Addresses the core problem
+- Respects all constraints
+- Meets specified requirements
+- ${iteration > 1 ? "Differs meaningfully from previous candidates" : "Provides a solid foundation"}
+- Is practical and implementable
+
+**Solution candidate #${iteration}:`;
+  }
+  buildSolutionEvaluationPrompt(input, thoughtManager) {
+    const solutions = thoughtManager.getThoughts().filter((t) => t.tags?.includes("solution_candidate"));
+    const hypotheses = thoughtManager.getTestedHypotheses();
+    const solutionsText = solutions.map((s, i) => `**Solution ${i + 1}** (Confidence: ${s.confidence.toFixed(2)}):
+${s.content}`).join(`
+
+`);
+    const hypothesesText = hypotheses.map((h) => `- ${h.statement}: ${h.result?.toUpperCase()} (${h.confidence.toFixed(2)})`).join(`
+`);
+    return `Evaluate all solution candidates and select the best one.
+
+**Problem:**
+${input.problemStatement}
+
+**Solution Candidates:**
+${solutionsText}
+
+**Hypothesis Test Results:**
+${hypothesesText || "No hypotheses tested"}
+
+**Evaluation Criteria:**
+- Effectiveness in solving the problem
+- Feasibility and practicality
+- Resource requirements
+- Risk level
+- Alignment with requirements and constraints
+
+**Task:**
+Select the best solution and provide:
+
+SELECTED_SOLUTION: [Your chosen solution statement]
+CONFIDENCE: [0.00-1.00]
+REASONING: [Why this solution is best]
+RECOMMENDATIONS: [Implementation recommendations, one per line]
+ALTERNATIVES: [Alternative solutions to consider, one per line]
+
+**Your evaluation:`;
+  }
+  buildImplementationPrompt(input, solution) {
+    return `Create a detailed implementation plan for the selected solution.
+
+**Problem:**
+${input.problemStatement}
+
+**Selected Solution:**
+${solution.statement}
+
+**Constraints:** ${input.constraints?.join(", ") || "None specified"}
+**Requirements:** ${input.requirements?.join(", ") || "None specified"}
+
+**Task:**
+Create a comprehensive implementation plan with:
+
+IMPLEMENTATION_STEPS: [Specific actionable steps, one per line]
+POTENTIAL_OBSTACLES: [Challenges that might arise, one per line]
+SUCCESS_CRITERIA: [How to measure success, one per line]
+TEST_PLAN: [How to validate the solution works, one per line]
+
+**Your implementation plan:`;
+  }
+  mapSolutionApproachToThinkingStyle(approach) {
+    const mapping = {
+      systematic: "systematic",
+      creative: "creative",
+      scientific: "scientific",
+      iterative: "analytical"
+    };
+    return mapping[approach] || "analytical";
+  }
+  getSolutionApproachInstructions(approach) {
+    const instructions = {
+      systematic: "Use structured, methodical problem-solving. Break down into components and address systematically.",
+      creative: "Think outside the box. Consider unconventional approaches and innovative solutions.",
+      scientific: "Use hypothesis-driven approach. Test assumptions and validate solutions with evidence.",
+      iterative: "Build solutions incrementally. Start simple and refine through iterations."
+    };
+    return instructions[approach] || instructions.systematic;
+  }
+  estimateSolutionConfidence(content, iteration, maxIterations) {
+    let confidence = 0.6;
+    if (iteration === 1)
+      confidence += 0.1;
+    if (iteration > maxIterations / 2)
+      confidence += 0.1;
+    if (content.includes("step") || content.includes("phase"))
+      confidence += 0.1;
+    if (content.includes("test") || content.includes("validate"))
+      confidence += 0.1;
+    if (content.length > 300)
+      confidence += 0.05;
+    return Math.min(confidence, 0.9);
+  }
+  parseSolutionEvaluation(content) {
+    const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => line);
+    let statement = "";
+    let confidence = 0.7;
+    const recommendations = [];
+    const alternatives = [];
+    let currentSection = "";
+    for (const line of lines) {
+      if (line.startsWith("SELECTED_SOLUTION:")) {
+        statement = line.replace("SELECTED_SOLUTION:", "").trim();
+      } else if (line.startsWith("CONFIDENCE:")) {
+        const confMatch = line.match(/(\d*\.?\d+)/);
+        if (confMatch && confMatch[1]) {
+          confidence = Math.min(Math.max(parseFloat(confMatch[1]), 0), 1);
+        }
+      } else if (line.startsWith("RECOMMENDATIONS:")) {
+        currentSection = "recommendations";
+      } else if (line.startsWith("ALTERNATIVES:")) {
+        currentSection = "alternatives";
+      } else if (line.startsWith("- ") || line.startsWith("* ")) {
+        const item = line.replace(/^[-*]\s*/, "");
+        if (currentSection === "recommendations") {
+          recommendations.push(item);
+        } else if (currentSection === "alternatives") {
+          alternatives.push(item);
+        }
+      }
+    }
+    return {
+      statement: statement || "Solution selected based on evaluation",
+      confidence,
+      recommendations,
+      alternatives
+    };
+  }
+  parseImplementationPlan(content) {
+    const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => line);
+    const steps = [];
+    const obstacles = [];
+    const successCriteria = [];
+    const testPlan = [];
+    let currentSection = "";
+    for (const line of lines) {
+      if (line.startsWith("IMPLEMENTATION_STEPS:")) {
+        currentSection = "steps";
+      } else if (line.startsWith("POTENTIAL_OBSTACLES:")) {
+        currentSection = "obstacles";
+      } else if (line.startsWith("SUCCESS_CRITERIA:")) {
+        currentSection = "criteria";
+      } else if (line.startsWith("TEST_PLAN:")) {
+        currentSection = "test";
+      } else if (line.startsWith("- ") || line.startsWith("* ")) {
+        const item = line.replace(/^[-*]\s*/, "");
+        switch (currentSection) {
+          case "steps":
+            steps.push(item);
+            break;
+          case "obstacles":
+            obstacles.push(item);
+            break;
+          case "criteria":
+            successCriteria.push(item);
+            break;
+          case "test":
+            testPlan.push(item);
+            break;
+        }
+      }
+    }
+    return { steps, obstacles, successCriteria, testPlan };
+  }
+  buildSolutionReasoning(process3) {
+    const solutions = process3.thoughts.filter((t) => t.tags?.includes("solution_candidate"));
+    const hypotheses = process3.hypotheses;
+    let reasoning = `Problem-Solving Process:
+
+`;
+    reasoning += `SOLUTION CANDIDATES (${solutions.length}):
+`;
+    solutions.forEach((sol, i) => {
+      reasoning += `${i + 1}. ${sol.content.substring(0, 150)}... [${(sol.confidence * 100).toFixed(0)}%]
+`;
+    });
+    if (hypotheses.length > 0) {
+      reasoning += `
+HYPOTHESIS TESTING:
+`;
+      hypotheses.forEach((hyp) => {
+        const status = hyp.tested ? hyp.result?.toUpperCase() : "NOT_TESTED";
+        reasoning += `• ${hyp.statement} → ${status}
+`;
+      });
+    }
+    return reasoning;
+  }
+  async pause(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+// src/tools/brain/processors/reflection.ts
+class ReflectionProcessor {
+  geminiClient;
+  constructor(geminiClient) {
+    this.geminiClient = geminiClient;
+  }
+  async process(input) {
+    const startTime = Date.now();
+    try {
+      logger2.info(`Starting reflection process for analysis of length: ${input.originalAnalysis.length}`);
+      const reflectionResults = await this.performReflection(input);
+      const identifiedIssues = await this.identifyIssues(input, reflectionResults);
+      const improvements = await this.generateImprovements(input, identifiedIssues);
+      const revisedAnalysis = await this.createRevisedAnalysis(input, improvements);
+      const confidence = this.calculateReflectionConfidence(identifiedIssues, improvements);
+      const recommendedActions = await this.generateRecommendedActions(input, improvements);
+      const processingTime = Date.now() - startTime;
+      return {
+        originalAnalysis: input.originalAnalysis,
+        revisedAnalysis: revisedAnalysis || undefined,
+        identifiedIssues,
+        improvements,
+        confidence,
+        recommendedActions
+      };
+    } catch (error) {
+      logger2.error("Reflection processing failed:", error);
+      throw new APIError(`Reflection failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async performReflection(input) {
+    const results = [];
+    for (const focus of input.reflectionFocus) {
+      try {
+        const reflectionPrompt = this.buildReflectionPrompt(input, focus);
+        const model = this.geminiClient.getModel("detailed");
+        const response = await model.generateContent(reflectionPrompt);
+        const content = response.response.text();
+        if (content) {
+          const parsed = this.parseReflectionResponse(content);
+          results.push({
+            focus,
+            analysis: parsed.analysis,
+            findings: parsed.findings
+          });
+        }
+        await this.pause(150);
+      } catch (error) {
+        logger2.warn(`Failed to perform reflection for ${focus}:`, error);
+      }
+    }
+    return results;
+  }
+  async identifyIssues(input, reflectionResults) {
+    const issues = [];
+    for (const result of reflectionResults) {
+      const issuePrompt = this.buildIssueIdentificationPrompt(input, result);
+      try {
+        const model = this.geminiClient.getModel("detailed");
+        const response = await model.generateContent(issuePrompt);
+        const content = response.response.text();
+        if (content) {
+          const parsedIssues = this.parseIssueResponse(content, result.focus);
+          issues.push(...parsedIssues);
+        }
+        await this.pause(100);
+      } catch (error) {
+        logger2.warn(`Failed to identify issues for ${result.focus}:`, error);
+      }
+    }
+    return issues;
+  }
+  async generateImprovements(input, issues) {
+    if (issues.length === 0) {
+      return ["Analysis appears sound", "Consider additional perspectives if needed"];
+    }
+    const improvementPrompt = this.buildImprovementPrompt(input, issues);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(improvementPrompt);
+      const content = response.response.text();
+      if (content) {
+        return this.parseImprovementResponse(content);
+      }
+    } catch (error) {
+      logger2.warn("Failed to generate improvements:", error);
+    }
+    return issues.filter((issue) => issue.severity === "high" || issue.severity === "medium").map((issue) => issue.suggestion).slice(0, 5);
+  }
+  async createRevisedAnalysis(input, improvements) {
+    const highImpactImprovements = improvements.filter((imp) => imp.includes("significant") || imp.includes("major") || imp.includes("critical"));
+    if (highImpactImprovements.length === 0) {
+      return null;
+    }
+    const revisionPrompt = this.buildRevisionPrompt(input, improvements);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(revisionPrompt);
+      const content = response.response.text();
+      return content || null;
+    } catch (error) {
+      logger2.warn("Failed to create revised analysis:", error);
+      return null;
+    }
+  }
+  async generateRecommendedActions(input, improvements) {
+    const actionPrompt = this.buildActionPrompt(input, improvements);
+    try {
+      const model = this.geminiClient.getModel("detailed");
+      const response = await model.generateContent(actionPrompt);
+      const content = response.response.text();
+      if (content) {
+        return this.parseActionResponse(content);
+      }
+    } catch (error) {
+      logger2.warn("Failed to generate recommended actions:", error);
+    }
+    return [
+      "Review identified issues",
+      "Implement suggested improvements",
+      "Validate revised analysis",
+      "Consider additional perspectives"
+    ];
+  }
+  buildReflectionPrompt(input, focus) {
+    const focusInstructions = this.getFocusInstructions(focus);
+    const contextInfo = this.formatReflectionContext(input);
+    return `You are conducting a reflective analysis focused on ${focus.replace("_", " ")}.
+
+${focusInstructions}
+
+**Original Analysis:**
+${input.originalAnalysis}
+
+${contextInfo}
+
+**Task:**
+Reflect on the original analysis specifically from the ${focus.replace("_", " ")} perspective.
+
+**Provide:**
+1. ANALYSIS: Your reflection on this aspect
+2. FINDINGS: Specific findings or concerns (one per line with - prefix)
+
+**Your reflection on ${focus.replace("_", " ")}:**`;
+  }
+  buildIssueIdentificationPrompt(input, result) {
+    return `Based on the reflection analysis, identify specific issues that need attention.
+
+**Focus Area:** ${result.focus.replace("_", " ")}
+
+**Reflection Analysis:**
+${result.analysis}
+
+**Key Findings:**
+${result.findings.map((f) => `- ${f}`).join(`
+`)}
+
+**Task:**
+Identify specific issues that need to be addressed.
+
+**For each issue, provide:**
+ISSUE: [Description of the issue]
+SEVERITY: [LOW|MEDIUM|HIGH]
+SUGGESTION: [How to address this issue]
+
+**Issues identified:`;
+  }
+  buildImprovementPrompt(input, issues) {
+    const issuesText = issues.map((issue) => `- ${issue.type}: ${issue.description} (${issue.severity}) → ${issue.suggestion}`).join(`
+`);
+    return `Generate specific improvements based on identified issues.
+
+**Original Analysis:**
+${input.originalAnalysis.substring(0, 500)}...
+
+**Identified Issues:**
+${issuesText}
+
+**Improvement Goals:**
+${input.improvementGoals?.join(", ") || "General improvement"}
+
+**Task:**
+Generate specific, actionable improvements to address the identified issues.
+
+**Improvements (one per line with - prefix):`;
+  }
+  buildRevisionPrompt(input, improvements) {
+    const improvementsText = improvements.map((imp) => `- ${imp}`).join(`
+`);
+    return `Create a revised version of the original analysis incorporating the suggested improvements.
+
+**Original Analysis:**
+${input.originalAnalysis}
+
+**Improvements to Incorporate:**
+${improvementsText}
+
+**New Information:**
+${input.newInformation || "None provided"}
+
+**Alternative Viewpoints:**
+${input.alternativeViewpoints?.join(", ") || "None provided"}
+
+**Task:**
+Create a revised analysis that addresses the identified issues and incorporates the improvements while maintaining the core insights from the original.
+
+**Revised Analysis:**`;
+  }
+  buildActionPrompt(input, improvements) {
+    const improvementsText = improvements.map((imp) => `- ${imp}`).join(`
+`);
+    return `Generate recommended actions based on the reflection and improvements.
+
+**Context:**
+${input.context ? JSON.stringify(input.context) : "No context provided"}
+
+**Identified Improvements:**
+${improvementsText}
+
+**Improvement Goals:**
+${input.improvementGoals?.join(", ") || "General improvement"}
+
+**Task:**
+Generate specific, actionable recommendations for next steps.
+
+**Recommended Actions (one per line with - prefix):`;
+  }
+  getFocusInstructions(focus) {
+    const instructions = {
+      assumptions: "Examine the underlying assumptions. Are they valid? Well-supported? What if they are wrong?",
+      logic_gaps: "Look for holes in the logical reasoning. Are there missing steps? Unsupported conclusions?",
+      alternative_approaches: "Consider different methods or perspectives. What other ways could this be approached?",
+      evidence_quality: "Evaluate the strength and reliability of evidence used. Is it sufficient and credible?",
+      bias_detection: "Identify potential biases in reasoning, data selection, or interpretation.",
+      consistency_check: "Check for internal consistency. Are there contradictions or conflicting statements?",
+      completeness: "Assess whether important aspects have been overlooked or inadequately addressed.",
+      feasibility: "Evaluate the practical viability and implementation challenges of conclusions or recommendations."
+    };
+    return instructions[focus] || "Reflect critically on this aspect of the analysis.";
+  }
+  formatReflectionContext(input) {
+    const parts = [];
+    if (input.newInformation) {
+      parts.push(`**New Information:** ${input.newInformation}`);
+    }
+    if (input.alternativeViewpoints?.length) {
+      parts.push(`**Alternative Viewpoints:** ${input.alternativeViewpoints.join(", ")}`);
+    }
+    if (input.improvementGoals?.length) {
+      parts.push(`**Improvement Goals:** ${input.improvementGoals.join(", ")}`);
+    }
+    return parts.length > 0 ? `
+` + parts.join(`
+`) + `
+` : "";
+  }
+  parseReflectionResponse(content) {
+    const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => line);
+    let analysis = "";
+    const findings = [];
+    let currentSection = "";
+    for (const line of lines) {
+      if (line.startsWith("ANALYSIS:")) {
+        currentSection = "analysis";
+        analysis = line.replace("ANALYSIS:", "").trim();
+      } else if (line.startsWith("FINDINGS:")) {
+        currentSection = "findings";
+      } else if (line.startsWith("- ") || line.startsWith("* ")) {
+        if (currentSection === "findings") {
+          findings.push(line.replace(/^[-*]\s*/, ""));
+        }
+      } else if (currentSection === "analysis" && line) {
+        analysis += (analysis ? " " : "") + line;
+      }
+    }
+    return {
+      analysis: analysis || "Reflection completed",
+      findings
+    };
+  }
+  parseIssueResponse(content, focus) {
+    const lines = content.split(`
+`).map((line) => line.trim()).filter((line) => line);
+    const issues = [];
+    let currentIssue = { type: focus };
+    for (const line of lines) {
+      if (line.startsWith("ISSUE:")) {
+        if (currentIssue.description) {
+          issues.push(currentIssue);
+        }
+        currentIssue = {
+          type: focus,
+          description: line.replace("ISSUE:", "").trim(),
+          severity: "medium",
+          suggestion: ""
+        };
+      } else if (line.startsWith("SEVERITY:")) {
+        const severityText = line.replace("SEVERITY:", "").trim().toLowerCase();
+        if (severityText.includes("high"))
+          currentIssue.severity = "high";
+        else if (severityText.includes("low"))
+          currentIssue.severity = "low";
+        else
+          currentIssue.severity = "medium";
+      } else if (line.startsWith("SUGGESTION:")) {
+        currentIssue.suggestion = line.replace("SUGGESTION:", "").trim();
+      }
+    }
+    if (currentIssue.description) {
+      issues.push(currentIssue);
+    }
+    return issues;
+  }
+  parseImprovementResponse(content) {
+    return content.split(`
+`).map((line) => line.trim()).filter((line) => line.startsWith("-") || line.startsWith("*")).map((line) => line.replace(/^[-*]\s*/, "")).filter((line) => line.length > 0).slice(0, 8);
+  }
+  parseActionResponse(content) {
+    return content.split(`
+`).map((line) => line.trim()).filter((line) => line.startsWith("-") || line.startsWith("*")).map((line) => line.replace(/^[-*]\s*/, "")).filter((line) => line.length > 0).slice(0, 6);
+  }
+  calculateReflectionConfidence(issues, improvements) {
+    const highSeverityIssues = issues.filter((i) => i.severity === "high").length;
+    const mediumSeverityIssues = issues.filter((i) => i.severity === "medium").length;
+    let confidence = 0.8;
+    confidence -= highSeverityIssues * 0.2;
+    confidence -= mediumSeverityIssues * 0.1;
+    if (improvements.length > 0)
+      confidence += 0.1;
+    return Math.max(Math.min(confidence, 1), 0.1);
+  }
+  async pause(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+// src/tools/brain/index.ts
+async function registerBrainTools(server, config) {
+  const geminiClient = new GeminiClient(config);
+  const sequentialThinkingProcessor = new SequentialThinkingProcessor(geminiClient);
+  const analyticalReasoningProcessor = new AnalyticalReasoningProcessor(geminiClient);
+  const problemSolverProcessor = new ProblemSolverProcessor(geminiClient);
+  const reflectionProcessor = new ReflectionProcessor(geminiClient);
+  logger2.info("Registering Brain tools for advanced reasoning capabilities...");
+  server.registerTool("brain_think", {
+    title: "Sequential Thinking Tool",
+    description: "Advanced sequential thinking with dynamic problem-solving and thought revision",
+    inputSchema: {
+      problem: exports_external.string().min(10).max(2000).describe("The problem or question to think through step by step"),
+      initialThoughts: exports_external.number().min(1).max(20).default(5).optional().describe("Number of initial thoughts to generate"),
+      thinkingStyle: exports_external.enum(["analytical", "systematic", "creative", "scientific", "critical", "strategic", "intuitive", "collaborative"]).default("analytical").optional().describe("Approach to use for thinking"),
+      context: exports_external.object({
+        domain: exports_external.string().optional(),
+        background: exports_external.string().optional(),
+        constraints: exports_external.array(exports_external.string()).optional(),
+        requirements: exports_external.array(exports_external.string()).optional(),
+        stakeholders: exports_external.array(exports_external.string()).optional(),
+        timeframe: exports_external.string().optional(),
+        resources: exports_external.array(exports_external.string()).optional()
+      }).optional().describe("Additional context for the problem"),
+      options: exports_external.object({
+        maxThoughts: exports_external.number().min(1).max(50).default(10).optional(),
+        allowRevision: exports_external.boolean().default(true).optional(),
+        enableBranching: exports_external.boolean().default(true).optional(),
+        requireEvidence: exports_external.boolean().default(false).optional(),
+        confidenceThreshold: exports_external.number().min(0).max(1).default(0.7).optional(),
+        timeLimit: exports_external.number().min(5).max(300).default(60).optional(),
+        outputDetail: exports_external.enum(["summary", "detailed", "complete"]).default("detailed").optional()
+      }).optional().describe("Processing options and constraints")
+    }
+  }, async (args) => {
+    try {
+      const input = {
+        problem: args.problem,
+        initialThoughts: args.initialThoughts || 5,
+        thinkingStyle: args.thinkingStyle || "analytical",
+        context: args.context,
+        options: args.options
+      };
+      const result = await sequentialThinkingProcessor.process(input);
+      return {
+        content: [{
+          type: "text",
+          text: formatThinkingResult(result)
+        }],
+        isError: false
+      };
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error("Tool brain_think error:", mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("brain_analyze", {
+    title: "Deep Analytical Reasoning Tool",
+    description: "Comprehensive analysis with branching exploration and assumption tracking",
+    inputSchema: {
+      subject: exports_external.string().min(10).max(2000).describe("The subject or topic to analyze deeply"),
+      analysisDepth: exports_external.enum(["surface", "detailed", "comprehensive"]).default("detailed").optional().describe("Depth of analysis to perform"),
+      focusAreas: exports_external.array(exports_external.string()).optional().describe("Specific areas to focus analysis on"),
+      thinkingStyle: exports_external.enum(["analytical", "systematic", "creative", "scientific", "critical", "strategic", "intuitive", "collaborative"]).default("analytical").optional().describe("Analytical approach to use"),
+      considerAlternatives: exports_external.boolean().default(true).optional().describe("Whether to explore alternative perspectives"),
+      trackAssumptions: exports_external.boolean().default(true).optional().describe("Whether to explicitly track assumptions"),
+      context: exports_external.object({
+        domain: exports_external.string().optional(),
+        background: exports_external.string().optional(),
+        constraints: exports_external.array(exports_external.string()).optional(),
+        requirements: exports_external.array(exports_external.string()).optional(),
+        stakeholders: exports_external.array(exports_external.string()).optional(),
+        timeframe: exports_external.string().optional(),
+        resources: exports_external.array(exports_external.string()).optional()
+      }).optional().describe("Context for the analysis"),
+      options: exports_external.object({
+        maxThoughts: exports_external.number().min(1).max(50).default(10).optional(),
+        allowRevision: exports_external.boolean().default(true).optional(),
+        enableBranching: exports_external.boolean().default(true).optional(),
+        requireEvidence: exports_external.boolean().default(false).optional(),
+        confidenceThreshold: exports_external.number().min(0).max(1).default(0.7).optional(),
+        timeLimit: exports_external.number().min(5).max(300).default(60).optional(),
+        outputDetail: exports_external.enum(["summary", "detailed", "complete"]).default("detailed").optional()
+      }).optional().describe("Processing options and constraints")
+    }
+  }, async (args) => {
+    try {
+      const input = {
+        subject: args.subject,
+        analysisDepth: args.analysisDepth || "detailed",
+        focusAreas: args.focusAreas,
+        thinkingStyle: args.thinkingStyle || "analytical",
+        considerAlternatives: args.considerAlternatives !== false,
+        trackAssumptions: args.trackAssumptions !== false,
+        context: args.context,
+        options: args.options
+      };
+      const result = await analyticalReasoningProcessor.process(input);
+      return {
+        content: [{
+          type: "text",
+          text: formatAnalysisResult(result)
+        }],
+        isError: false
+      };
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error("Tool brain_analyze error:", mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("brain_solve", {
+    title: "Problem Solving Tool",
+    description: "Multi-step problem solving with hypothesis testing and solution evaluation",
+    inputSchema: {
+      problemStatement: exports_external.string().min(10).max(2000).describe("Clear statement of the problem to solve"),
+      solutionApproach: exports_external.enum(["systematic", "creative", "scientific", "iterative"]).default("systematic").optional().describe("Approach to problem solving"),
+      constraints: exports_external.array(exports_external.string()).optional().describe("Constraints that limit possible solutions"),
+      requirements: exports_external.array(exports_external.string()).optional().describe("Requirements the solution must meet"),
+      verifyHypotheses: exports_external.boolean().default(true).optional().describe("Whether to test hypotheses scientifically"),
+      maxIterations: exports_external.number().min(1).max(20).default(10).optional().describe("Maximum solution iterations to attempt"),
+      context: exports_external.object({
+        domain: exports_external.string().optional(),
+        background: exports_external.string().optional(),
+        constraints: exports_external.array(exports_external.string()).optional(),
+        requirements: exports_external.array(exports_external.string()).optional(),
+        stakeholders: exports_external.array(exports_external.string()).optional(),
+        timeframe: exports_external.string().optional(),
+        resources: exports_external.array(exports_external.string()).optional()
+      }).optional().describe("Context for the problem"),
+      options: exports_external.object({
+        maxThoughts: exports_external.number().min(1).max(50).default(10).optional(),
+        allowRevision: exports_external.boolean().default(true).optional(),
+        enableBranching: exports_external.boolean().default(true).optional(),
+        requireEvidence: exports_external.boolean().default(false).optional(),
+        confidenceThreshold: exports_external.number().min(0).max(1).default(0.7).optional(),
+        timeLimit: exports_external.number().min(5).max(300).default(60).optional(),
+        outputDetail: exports_external.enum(["summary", "detailed", "complete"]).default("detailed").optional()
+      }).optional().describe("Processing options and constraints")
+    }
+  }, async (args) => {
+    try {
+      const input = {
+        problemStatement: args.problemStatement,
+        solutionApproach: args.solutionApproach || "systematic",
+        constraints: args.constraints,
+        requirements: args.requirements,
+        verifyHypotheses: args.verifyHypotheses !== false,
+        maxIterations: args.maxIterations || 10,
+        context: args.context,
+        options: args.options
+      };
+      const result = await problemSolverProcessor.process(input);
+      return {
+        content: [{
+          type: "text",
+          text: formatSolutionResult(result)
+        }],
+        isError: false
+      };
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error("Tool brain_solve error:", mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("brain_reflect", {
+    title: "Thought Reflection Tool",
+    description: "Reflect on and improve previous analysis through meta-cognitive examination",
+    inputSchema: {
+      originalAnalysis: exports_external.string().min(50).max(5000).describe("The original analysis or reasoning to reflect on"),
+      reflectionFocus: exports_external.array(exports_external.enum(["assumptions", "logic_gaps", "alternative_approaches", "evidence_quality", "bias_detection", "consistency_check", "completeness", "feasibility"])).min(1).describe("Aspects to focus reflection on"),
+      improvementGoals: exports_external.array(exports_external.string()).optional().describe("Specific goals for improvement"),
+      newInformation: exports_external.string().optional().describe("Any new information to consider"),
+      alternativeViewpoints: exports_external.array(exports_external.string()).optional().describe("Alternative perspectives to consider"),
+      context: exports_external.object({
+        domain: exports_external.string().optional(),
+        background: exports_external.string().optional(),
+        constraints: exports_external.array(exports_external.string()).optional(),
+        requirements: exports_external.array(exports_external.string()).optional(),
+        stakeholders: exports_external.array(exports_external.string()).optional(),
+        timeframe: exports_external.string().optional(),
+        resources: exports_external.array(exports_external.string()).optional()
+      }).optional().describe("Context for the reflection"),
+      options: exports_external.object({
+        maxThoughts: exports_external.number().min(1).max(50).default(10).optional(),
+        allowRevision: exports_external.boolean().default(true).optional(),
+        enableBranching: exports_external.boolean().default(true).optional(),
+        requireEvidence: exports_external.boolean().default(false).optional(),
+        confidenceThreshold: exports_external.number().min(0).max(1).default(0.7).optional(),
+        timeLimit: exports_external.number().min(5).max(300).default(60).optional(),
+        outputDetail: exports_external.enum(["summary", "detailed", "complete"]).default("detailed").optional()
+      }).optional().describe("Processing options and constraints")
+    }
+  }, async (args) => {
+    try {
+      const input = {
+        originalAnalysis: args.originalAnalysis,
+        reflectionFocus: args.reflectionFocus,
+        improvementGoals: args.improvementGoals,
+        newInformation: args.newInformation,
+        alternativeViewpoints: args.alternativeViewpoints,
+        context: args.context,
+        options: args.options
+      };
+      const result = await reflectionProcessor.process(input);
+      return {
+        content: [{
+          type: "text",
+          text: formatReflectionResult(result)
+        }],
+        isError: false
+      };
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error("Tool brain_reflect error:", mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  logger2.info("Successfully registered 4 Brain tools: brain_think, brain_analyze, brain_solve, brain_reflect");
+}
+function formatThinkingResult(result) {
+  const header = `# Sequential Thinking Results
+
+`;
+  const summary = `## Summary
+` + `**Problem:** ${result.thoughtProcess.problem}
+` + `**Final Answer:** ${result.finalAnswer}
+` + `**Confidence:** ${(result.confidence * 100).toFixed(1)}%
+` + `**Thoughts Generated:** ${result.processingInfo.totalThoughts}
+` + `**Processing Time:** ${(result.processingInfo.processingTime / 1000).toFixed(1)}s
+
+`;
+  const thoughts = `## Thought Process
+` + result.thoughtProcess.thoughts.map((thought, index) => {
+    const revisionMark = thought.isRevision ? " ↻" : "";
+    const branchMark = thought.branchId ? " \uD83C\uDF3F" : "";
+    return `**${index + 1}.** ${thought.content} [${(thought.confidence * 100).toFixed(0)}%]${revisionMark}${branchMark}`;
+  }).join(`
+
+`) + `
+
+`;
+  const recommendations = result.recommendations?.length > 0 ? `## Recommendations
+${result.recommendations.map((rec) => `• ${rec}`).join(`
+`)}
+
+` : "";
+  const nextSteps = result.nextSteps?.length > 0 ? `## Next Steps
+${result.nextSteps.map((step) => `• ${step}`).join(`
+`)}
+
+` : "";
+  return header + summary + thoughts + recommendations + nextSteps;
+}
+function formatAnalysisResult(result) {
+  const header = `# Deep Analysis Results
+
+`;
+  const summary = `## Analysis Summary
+` + `**Subject:** ${result.thoughtProcess.problem}
+` + `**Final Conclusion:** ${result.finalAnswer}
+` + `**Confidence:** ${(result.confidence * 100).toFixed(1)}%
+` + `**Evidence Quality:** ${result.evidenceQuality.toUpperCase()}
+
+`;
+  const keyFindings = result.keyFindings?.length > 0 ? `## Key Findings
+${result.keyFindings.map((finding) => `• ${finding}`).join(`
+`)}
+
+` : "";
+  const assumptions = result.assumptions?.length > 0 ? `## Key Assumptions
+${result.assumptions.map((assumption) => `• ${assumption}`).join(`
+`)}
+
+` : "";
+  const risks = result.riskFactors?.length > 0 ? `## Risk Factors
+${result.riskFactors.map((risk) => `⚠️ ${risk}`).join(`
+`)}
+
+` : "";
+  const opportunities = result.opportunities?.length > 0 ? `## Opportunities
+${result.opportunities.map((opp) => `✨ ${opp}`).join(`
+`)}
+
+` : "";
+  return header + summary + keyFindings + assumptions + risks + opportunities;
+}
+function formatSolutionResult(result) {
+  const header = `# Problem Solving Results
+
+`;
+  const summary = `## Solution Summary
+` + `**Problem:** ${result.thoughtProcess.problem}
+` + `**Proposed Solution:** ${result.proposedSolution}
+` + `**Confidence:** ${(result.confidence * 100).toFixed(1)}%
+` + `**Hypotheses Tested:** ${result.processingInfo.hypothesesTested}
+
+`;
+  const implementation = result.implementationSteps?.length > 0 ? `## Implementation Steps
+${result.implementationSteps.map((step, i) => `${i + 1}. ${step}`).join(`
+`)}
+
+` : "";
+  const obstacles = result.potentialObstacles?.length > 0 ? `## Potential Obstacles
+${result.potentialObstacles.map((obs) => `⚠️ ${obs}`).join(`
+`)}
+
+` : "";
+  const success = result.successCriteria?.length > 0 ? `## Success Criteria
+${result.successCriteria.map((crit) => `✅ ${crit}`).join(`
+`)}
+
+` : "";
+  const fallbacks = result.fallbackOptions?.length > 0 ? `## Fallback Options
+${result.fallbackOptions.map((option) => `• ${option}`).join(`
+`)}
+
+` : "";
+  return header + summary + implementation + obstacles + success + fallbacks;
+}
+function formatReflectionResult(result) {
+  const header = `# Reflection Analysis Results
+
+`;
+  const summary = `## Reflection Summary
+` + `**Confidence in Analysis:** ${(result.confidence * 100).toFixed(1)}%
+` + `**Issues Identified:** ${result.identifiedIssues.length}
+` + `**Improvements Suggested:** ${result.improvements.length}
+
+`;
+  const issues = result.identifiedIssues?.length > 0 ? `## Identified Issues
+` + result.identifiedIssues.map((issue) => {
+    const severity = issue.severity.toUpperCase();
+    const icon = severity === "HIGH" ? "\uD83D\uDD34" : severity === "MEDIUM" ? "\uD83D\uDFE1" : "\uD83D\uDFE2";
+    return `${icon} **${issue.type.replace("_", " ").toUpperCase()}:** ${issue.description}
+   *Suggestion:* ${issue.suggestion}`;
+  }).join(`
+
+`) + `
+
+` : "";
+  const improvements = result.improvements?.length > 0 ? `## Suggested Improvements
+${result.improvements.map((imp) => `• ${imp}`).join(`
+`)}
+
+` : "";
+  const revised = result.revisedAnalysis ? `## Revised Analysis
+${result.revisedAnalysis}
+
+` : "";
+  const actions = result.recommendedActions?.length > 0 ? `## Recommended Actions
+${result.recommendedActions.map((action) => `• ${action}`).join(`
+`)}
+
+` : "";
+  return header + summary + issues + improvements + revised + actions;
+}
+
 // src/prompts/debugging-prompts.ts
 var debuggingPrompts = [
   {
@@ -166668,6 +169050,7 @@ async function createServer() {
   await registerEyesTool(server, config);
   await registerHandsTool(server, config);
   await registerMouthTool(server, config);
+  await registerBrainTools(server, config);
   await registerPrompts(server);
   await registerResources(server);
   return server;