deepthinking-mcp 5.0.1 → 6.0.0

package/README.md

@@ -4,11 +4,11 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-green.svg)](https://modelcontextprotocol.io)
 
-A comprehensive Model Context Protocol (MCP) server featuring **18 advanced reasoning modes** with intelligent mode recommendation, taxonomy-based classification, enterprise security, and production-ready features for complex problem-solving, analysis, and decision-making.
+A comprehensive Model Context Protocol (MCP) server featuring **21 advanced reasoning modes** including meta-reasoning for strategic oversight, with intelligent mode recommendation, taxonomy-based classification, enterprise security, and production-ready features for complex problem-solving, analysis, and decision-making.
 
-> 📋 **Latest Release**: v4.3.0 - See [CHANGELOG](CHANGELOG.md) for updates and improvements.
+> 📋 **Latest Release**: v6.0.0 - See [CHANGELOG](CHANGELOG.md) for updates and improvements.
 >
-> 🎉 **New in v4.3.0**: Visual export modularization, lazy validator loading, code redundancy elimination, tree-shaking optimizations!
+> 🎉 **New in v6.0.0**: Meta-Reasoning mode for strategic oversight! Monitor reasoning effectiveness, get adaptive mode-switching recommendations, and assess quality metrics across 6 dimensions.
 
 ## Table of Contents
 
@@ -24,10 +24,12 @@ A comprehensive Model Context Protocol (MCP) server featuring **18 advanced reas
 
 ## Features
 
-- **18 Specialized Reasoning Modes** - From sequential thinking to game theory and formal logic
+- **21 Specialized Reasoning Modes** - From sequential thinking to game theory, formal logic, and meta-reasoning
+- **Meta-Reasoning (NEW!)** - Strategic oversight that monitors effectiveness, recommends mode switches, and assesses quality
+- **Adaptive Mode Switching** - Automatic evaluation-based mode switching when effectiveness drops below thresholds
 - **Intelligent Mode Recommendation** - Automatic mode selection based on problem characteristics
 - **Taxonomy Classifier** - 110+ reasoning types across 12 categories for intelligent task classification
-- **Visual Exports** - Generate Mermaid diagrams, DOT graphs, ASCII art, and LaTeX documents
+- **Visual Exports** - Generate Mermaid diagrams, DOT graphs, ASCII art, and LaTeX documents with meta-insights
 - **Production-Ready** - Search engine, templates, batch processing, caching, backup/restore
 - **Enterprise Security** - Input validation (Zod), rate limiting, path sanitization, PII redaction
 - **High Performance** - LRU caching with auto-eviction, async I/O, 4-5x validation speedups
@@ -225,6 +227,18 @@ mode: 'first-principles'
 // Use for: Fundamental analysis, conceptual understanding, basic truths
 ```
 
+#### Meta-Reasoning ⭐ NEW
+Strategic oversight of reasoning process - monitors effectiveness, recommends mode switches, assesses quality.
+
+```typescript
+mode: 'metareasoning'
+// Use for: Strategy evaluation, adaptive mode switching, quality assessment
+// Metrics: Effectiveness, Efficiency, Confidence, Quality (6 dimensions)
+// Auto-switches at effectiveness < 0.3
+```
+
+See [full documentation](docs/modes/METAREASONING.md) for detailed usage.
+
 #### Systems Thinking
 Holistic analysis of complex systems, feedback loops, and emergence.
 

package/dist/index.js

@@ -815,6 +815,9 @@ function isGameTheoryThought(thought) {
 function isEvidentialThought(thought) {
   return thought.mode === "evidential" /* EVIDENTIAL */;
 }
+function isMetaReasoningThought(thought) {
+  return thought.mode === "metareasoning" /* METAREASONING */;
+}
 var init_core = __esm({
   "src/types/core.ts"() {
     init_esm_shims();
@@ -881,6 +884,16 @@ var init_recommendations = __esm({
             examples: ["Scientific explanation", "Debugging", "Diagnosis", "Theory selection", "Metaphysical arguments"]
           });
         }
+        if (characteristics.complexity === "high" || characteristics.hasAlternatives && characteristics.uncertainty === "high") {
+          recommendations.push({
+            mode: "metareasoning" /* METAREASONING */,
+            score: characteristics.complexity === "high" ? 0.88 : 0.82,
+            reasoning: "Complex or uncertain problems benefit from strategic monitoring and adaptive reasoning",
+            strengths: ["Strategy evaluation", "Mode switching recommendations", "Quality monitoring", "Resource allocation", "Self-reflection"],
+            limitations: ["Meta-level overhead", "Requires understanding of other modes", "May not directly solve the problem"],
+            examples: ["Strategy selection", "Debugging stuck reasoning", "Quality assessment", "Adaptive problem-solving"]
+          });
+        }
         if (characteristics.timeDependent) {
           recommendations.push({
             mode: "temporal" /* TEMPORAL */,
@@ -1084,6 +1097,11 @@ var init_recommendations = __esm({
           "synthesis": "hybrid" /* HYBRID */,
           "philosophical": "hybrid" /* HYBRID */,
           "metaphysical": "hybrid" /* HYBRID */,
+          // Meta-reasoning
+          "meta": "metareasoning" /* METAREASONING */,
+          "strategy-selection": "metareasoning" /* METAREASONING */,
+          "quality-assessment": "metareasoning" /* METAREASONING */,
+          "reflection": "metareasoning" /* METAREASONING */,
           // Specialized modes
           "debugging": "abductive" /* ABDUCTIVE */,
           "mathematical": "mathematics" /* MATHEMATICS */,
@@ -1970,6 +1988,218 @@ var init_SessionMetricsCalculator = __esm({
     };
   }
 });
+
+// src/services/MetaMonitor.ts
+var MetaMonitor, metaMonitor;
+var init_MetaMonitor = __esm({
+  "src/services/MetaMonitor.ts"() {
+    init_esm_shims();
+    MetaMonitor = class {
+      sessionHistory = /* @__PURE__ */ new Map();
+      currentStrategies = /* @__PURE__ */ new Map();
+      modeTransitions = /* @__PURE__ */ new Map();
+      /**
+       * Record a thought in session history
+       */
+      recordThought(sessionId, thought) {
+        if (!this.sessionHistory.has(sessionId)) {
+          this.sessionHistory.set(sessionId, []);
+        }
+        const history = this.sessionHistory.get(sessionId);
+        history.push({
+          thoughtId: thought.id,
+          mode: thought.mode,
+          timestamp: thought.timestamp,
+          content: thought.content,
+          uncertainty: "uncertainty" in thought ? thought.uncertainty : void 0
+        });
+        if (!this.modeTransitions.has(sessionId)) {
+          this.modeTransitions.set(sessionId, []);
+        }
+        const transitions = this.modeTransitions.get(sessionId);
+        if (transitions.length === 0 || transitions[transitions.length - 1] !== thought.mode) {
+          transitions.push(thought.mode);
+        }
+      }
+      /**
+       * Start tracking a new strategy
+       */
+      startStrategy(sessionId, mode) {
+        this.currentStrategies.set(sessionId, {
+          mode,
+          thoughtsSpent: 0,
+          startTime: /* @__PURE__ */ new Date(),
+          progressIndicators: [],
+          issuesEncountered: []
+        });
+      }
+      /**
+       * Update current strategy progress
+       */
+      updateStrategyProgress(sessionId, indicator) {
+        const strategy = this.currentStrategies.get(sessionId);
+        if (strategy) {
+          strategy.progressIndicators.push(indicator);
+          strategy.thoughtsSpent++;
+        }
+      }
+      /**
+       * Record an issue with current strategy
+       */
+      recordStrategyIssue(sessionId, issue) {
+        const strategy = this.currentStrategies.get(sessionId);
+        if (strategy) {
+          strategy.issuesEncountered.push(issue);
+        }
+      }
+      /**
+       * Evaluate current strategy effectiveness
+       */
+      evaluateStrategy(sessionId) {
+        const strategy = this.currentStrategies.get(sessionId);
+        if (!strategy) {
+          return {
+            effectiveness: 0.5,
+            efficiency: 0.5,
+            confidence: 0.5,
+            progressRate: 0,
+            qualityScore: 0.5,
+            issues: ["No active strategy being tracked"],
+            strengths: []
+          };
+        }
+        const thoughtsSpent = strategy.thoughtsSpent;
+        const progressMade = strategy.progressIndicators.length;
+        const issuesCount = strategy.issuesEncountered.length;
+        const timeElapsed = (/* @__PURE__ */ new Date()).getTime() - strategy.startTime.getTime();
+        const effectiveness = Math.min(1, progressMade / Math.max(1, thoughtsSpent));
+        const efficiency = timeElapsed > 0 ? Math.min(1, progressMade / (timeElapsed / 6e4)) : 0.5;
+        const confidence = Math.max(0.1, 1 - issuesCount * 0.15);
+        const progressRate = thoughtsSpent > 0 ? progressMade / thoughtsSpent : 0;
+        const qualityScore = effectiveness * 0.4 + efficiency * 0.2 + confidence * 0.4;
+        return {
+          effectiveness,
+          efficiency,
+          confidence,
+          progressRate,
+          qualityScore,
+          issues: [...strategy.issuesEncountered],
+          strengths: strategy.progressIndicators.slice(-3)
+          // Recent progress
+        };
+      }
+      /**
+       * Suggest alternative strategies based on current performance
+       */
+      suggestAlternatives(sessionId, currentMode) {
+        const evaluation = this.evaluateStrategy(sessionId);
+        const alternatives = [];
+        if (evaluation.effectiveness < 0.4) {
+          if (currentMode !== "hybrid" /* HYBRID */) {
+            alternatives.push({
+              mode: "hybrid" /* HYBRID */,
+              reasoning: "Low effectiveness detected - hybrid multi-modal approach may provide better results",
+              expectedBenefit: "Combines multiple reasoning types for comprehensive analysis",
+              switchingCost: 0.3,
+              recommendationScore: 0.85
+            });
+          }
+          if (currentMode !== "inductive" /* INDUCTIVE */) {
+            alternatives.push({
+              mode: "inductive" /* INDUCTIVE */,
+              reasoning: "Consider gathering more empirical observations",
+              expectedBenefit: "Build stronger generalizations from specific cases",
+              switchingCost: 0.2,
+              recommendationScore: 0.7
+            });
+          }
+        }
+        if (evaluation.effectiveness >= 0.4 && evaluation.efficiency < 0.5) {
+          alternatives.push({
+            mode: currentMode,
+            // Same mode, but recommend refinement
+            reasoning: "Progress detected but efficiency is low - consider refining current approach",
+            expectedBenefit: "Improved efficiency while maintaining progress",
+            switchingCost: 0.1,
+            recommendationScore: 0.65
+          });
+        }
+        return alternatives;
+      }
+      /**
+       * Calculate quality metrics for current session
+       */
+      calculateQualityMetrics(sessionId) {
+        const history = this.sessionHistory.get(sessionId) || [];
+        const strategy = this.currentStrategies.get(sessionId);
+        if (history.length === 0) {
+          return {
+            logicalConsistency: 0.5,
+            evidenceQuality: 0.5,
+            completeness: 0.5,
+            originality: 0.5,
+            clarity: 0.5,
+            overallQuality: 0.5
+          };
+        }
+        const issuesCount = strategy?.issuesEncountered.length || 0;
+        const logicalConsistency = Math.max(0.1, 1 - issuesCount * 0.1);
+        const avgUncertainty = history.reduce((sum, entry) => sum + (entry.uncertainty || 0.5), 0) / history.length;
+        const evidenceQuality = 1 - avgUncertainty;
+        const completeness = Math.min(1, history.length / 5);
+        const uniqueModes = new Set(history.map((h) => h.mode)).size;
+        const originality = Math.min(1, uniqueModes / 3);
+        const progressCount = strategy?.progressIndicators.length || 0;
+        const clarity = Math.min(1, progressCount / Math.max(1, history.length));
+        const overallQuality = logicalConsistency * 0.25 + evidenceQuality * 0.2 + completeness * 0.15 + originality * 0.15 + clarity * 0.25;
+        return {
+          logicalConsistency,
+          evidenceQuality,
+          completeness,
+          originality,
+          clarity,
+          overallQuality
+        };
+      }
+      /**
+       * Get session context for meta-reasoning
+       */
+      getSessionContext(sessionId, problemType) {
+        const history = this.sessionHistory.get(sessionId) || [];
+        const transitions = this.modeTransitions.get(sessionId) || [];
+        return {
+          sessionId,
+          totalThoughts: history.length,
+          modesUsed: transitions,
+          modeSwitches: Math.max(0, transitions.length - 1),
+          problemType,
+          historicalEffectiveness: this.getHistoricalEffectiveness(problemType)
+        };
+      }
+      /**
+       * Get historical effectiveness for similar problems (simplified)
+       */
+      getHistoricalEffectiveness(_problemType) {
+        return void 0;
+      }
+      /**
+       * Clear session data (for cleanup)
+       */
+      clearSession(sessionId) {
+        this.sessionHistory.delete(sessionId);
+        this.currentStrategies.delete(sessionId);
+        this.modeTransitions.delete(sessionId);
+      }
+      /**
+       * Get all tracked sessions
+       */
+      getActiveSessions() {
+        return Array.from(this.sessionHistory.keys());
+      }
+    };
+    metaMonitor = new MetaMonitor();
+  }
+});
 var DEFAULT_CONFIG2, SessionManager;
 var init_manager = __esm({
   "src/session/manager.ts"() {
@@ -1979,6 +2209,7 @@ var init_manager = __esm({
     init_logger();
     init_lru();
     init_SessionMetricsCalculator();
+    init_MetaMonitor();
     DEFAULT_CONFIG2 = {
       modeConfig: {
         mode: "hybrid" /* HYBRID */,
@@ -2000,12 +2231,14 @@ var init_manager = __esm({
       logger;
       storage;
       metricsCalculator;
+      monitor;
       /**
        * Creates a new SessionManager instance
        *
        * @param config - Optional default configuration applied to all new sessions
        * @param logger - Optional logger instance or log level (default: INFO level logger)
        * @param storage - Optional persistent storage backend for sessions
+       * @param monitor - Optional MetaMonitor instance for dependency injection
        *
        * @example
        * ```typescript
@@ -2027,7 +2260,7 @@ var init_manager = __esm({
        * const manager = new SessionManager({}, LogLevel.INFO, storage);
        * ```
        */
-      constructor(config, logger2, storage) {
+      constructor(config, logger2, storage, monitor) {
         this.activeSessions = new LRUCache({
           maxSize: 1e3,
           enableStats: true,
@@ -2040,10 +2273,14 @@ var init_manager = __esm({
                 this.logger.error("Failed to save evicted session", error, { sessionId: key });
               }
             }
+            if (this.monitor) {
+              this.monitor.clearSession(key);
+            }
           }
         });
         this.config = config || {};
         this.storage = storage;
+        this.monitor = monitor || metaMonitor;
         if (logger2 && typeof logger2 === "object" && "info" in logger2) {
           this.logger = logger2;
         } else {
@@ -2109,6 +2346,7 @@ var init_manager = __esm({
             this.logger.error("Failed to persist session", error, { sessionId });
           }
         }
+        this.monitor.startStrategy(sessionId, session.mode);
         this.logger.info("Session created", {
           sessionId,
           title,
@@ -2192,6 +2430,7 @@ var init_manager = __esm({
         session.currentThoughtNumber = thought.thoughtNumber;
         session.updatedAt = /* @__PURE__ */ new Date();
         this.metricsCalculator.updateMetrics(session, thought);
+        this.monitor.recordThought(sessionId, thought);
         if (!thought.nextThoughtNeeded) {
           session.isComplete = true;
           this.logger.info("Session completed", {
@@ -2687,6 +2926,58 @@ var init_ThoughtFactory = __esm({
               conclusion: input.conclusion || { statement: "", derivationChain: [], certainty: 0 },
               alternativeInterpretations: input.alternativeInterpretations || []
             };
+          case "metareasoning": {
+            const metaInput = input;
+            return {
+              ...baseThought,
+              mode: "metareasoning" /* METAREASONING */,
+              currentStrategy: metaInput.currentStrategy || {
+                mode: "sequential" /* SEQUENTIAL */,
+                approach: "Default sequential approach",
+                startedAt: /* @__PURE__ */ new Date(),
+                thoughtsSpent: 0,
+                progressIndicators: []
+              },
+              strategyEvaluation: metaInput.strategyEvaluation || {
+                effectiveness: 0.5,
+                efficiency: 0.5,
+                confidence: 0.5,
+                progressRate: 0,
+                qualityScore: 0.5,
+                issues: [],
+                strengths: []
+              },
+              alternativeStrategies: metaInput.alternativeStrategies || [],
+              recommendation: metaInput.recommendation || {
+                action: "CONTINUE",
+                justification: "No specific recommendation yet",
+                confidence: 0.5,
+                expectedImprovement: "Monitor progress"
+              },
+              resourceAllocation: metaInput.resourceAllocation || {
+                timeSpent: 0,
+                thoughtsRemaining: input.totalThoughts - input.thoughtNumber,
+                complexityLevel: "medium",
+                urgency: "medium",
+                recommendation: "Continue with current approach"
+              },
+              qualityMetrics: metaInput.qualityMetrics || {
+                logicalConsistency: 0.5,
+                evidenceQuality: 0.5,
+                completeness: 0.5,
+                originality: 0.5,
+                clarity: 0.5,
+                overallQuality: 0.5
+              },
+              sessionContext: metaInput.sessionContext || {
+                sessionId,
+                totalThoughts: input.thoughtNumber,
+                modesUsed: [input.mode],
+                modeSwitches: 0,
+                problemType: "general"
+              }
+            };
+          }
           case "hybrid":
           default:
             return {
@@ -4982,6 +5273,7 @@ var ExportService;
 var init_ExportService = __esm({
   "src/services/ExportService.ts"() {
     init_esm_shims();
+    init_types();
     init_visual();
     init_sanitization();
     init_logger();
@@ -5162,6 +5454,79 @@ ${thoughts}`;
           md += `${thought.content}
 
 `;
+          if (isMetaReasoningThought(thought)) {
+            md += `#### \u{1F4CA} Meta-Reasoning Analysis
+
+`;
+            md += `**Current Strategy:**
+`;
+            md += `- Mode: ${thought.currentStrategy.mode}
+`;
+            md += `- Approach: ${thought.currentStrategy.approach}
+`;
+            md += `- Thoughts Spent: ${thought.currentStrategy.thoughtsSpent}
+`;
+            if (thought.currentStrategy.progressIndicators.length > 0) {
+              md += `- Progress: ${thought.currentStrategy.progressIndicators.join(", ")}
+`;
+            }
+            md += `
+`;
+            md += `**Strategy Evaluation:**
+`;
+            md += `- Effectiveness: ${(thought.strategyEvaluation.effectiveness * 100).toFixed(1)}%
+`;
+            md += `- Efficiency: ${(thought.strategyEvaluation.efficiency * 100).toFixed(1)}%
+`;
+            md += `- Confidence: ${(thought.strategyEvaluation.confidence * 100).toFixed(1)}%
+`;
+            md += `- Quality Score: ${(thought.strategyEvaluation.qualityScore * 100).toFixed(1)}%
+`;
+            if (thought.strategyEvaluation.issues.length > 0) {
+              md += `- Issues: ${thought.strategyEvaluation.issues.join("; ")}
+`;
+            }
+            if (thought.strategyEvaluation.strengths.length > 0) {
+              md += `- Strengths: ${thought.strategyEvaluation.strengths.join("; ")}
+`;
+            }
+            md += `
+`;
+            md += `**Recommendation:** ${thought.recommendation.action}
+`;
+            md += `- ${thought.recommendation.justification}
+`;
+            md += `- Confidence: ${(thought.recommendation.confidence * 100).toFixed(1)}%
+`;
+            md += `- Expected Improvement: ${thought.recommendation.expectedImprovement}
+`;
+            if (thought.alternativeStrategies.length > 0) {
+              md += `
+**Alternative Strategies:**
+`;
+              for (const alt of thought.alternativeStrategies) {
+                md += `- **${alt.mode}** (score: ${(alt.recommendationScore * 100).toFixed(0)}%): ${alt.reasoning}
+`;
+              }
+            }
+            md += `
+**Quality Metrics:**
+`;
+            md += `- Logical Consistency: ${(thought.qualityMetrics.logicalConsistency * 100).toFixed(1)}%
+`;
+            md += `- Evidence Quality: ${(thought.qualityMetrics.evidenceQuality * 100).toFixed(1)}%
+`;
+            md += `- Completeness: ${(thought.qualityMetrics.completeness * 100).toFixed(1)}%
+`;
+            md += `- Originality: ${(thought.qualityMetrics.originality * 100).toFixed(1)}%
+`;
+            md += `- Clarity: ${(thought.qualityMetrics.clarity * 100).toFixed(1)}%
+`;
+            md += `- Overall Quality: ${(thought.qualityMetrics.overallQuality * 100).toFixed(1)}%
+`;
+            md += `
+`;
+          }
         }
         return md;
       }
@@ -5320,27 +5685,31 @@ var init_ModeRouter = __esm({
     init_esm_shims();
     init_types();
     init_logger();
+    init_MetaMonitor();
     ModeRouter = class {
       sessionManager;
       recommender;
       logger;
+      monitor;
       /**
        * Create a new ModeRouter
        *
        * @param sessionManager - Session manager instance for mode switching
        * @param logger - Optional logger for dependency injection
+       * @param monitor - Optional MetaMonitor instance for dependency injection
        *
        * @example
        * ```typescript
        * const router = new ModeRouter(sessionManager);
        * // Or with DI:
-       * const router = new ModeRouter(sessionManager, customLogger);
+       * const router = new ModeRouter(sessionManager, customLogger, customMonitor);
        * ```
        */
-      constructor(sessionManager, logger2) {
+      constructor(sessionManager, logger2, monitor) {
         this.sessionManager = sessionManager;
         this.recommender = new ModeRecommender();
         this.logger = logger2 || createLogger({ minLevel: 1 /* INFO */, enableConsole: true });
+        this.monitor = monitor || metaMonitor;
       }
       /**
        * Switch a session to a new thinking mode
@@ -5501,6 +5870,96 @@ var init_ModeRouter = __esm({
 
 For more detailed recommendations, provide problemCharacteristics.`;
       }
+      /**
+       * Evaluate current session and suggest mode switch if beneficial
+       *
+       * Uses meta-reasoning to evaluate the current strategy effectiveness
+       * and suggest alternative modes if the current approach is suboptimal.
+       *
+       * @param sessionId - Session to evaluate
+       * @param problemType - Optional problem type for context
+       * @returns Evaluation result with switch recommendation
+       *
+       * @example
+       * ```typescript
+       * const evaluation = await router.evaluateAndSuggestSwitch('session-123', 'debugging');
+       * if (evaluation.shouldSwitch) {
+       *   await router.switchMode(sessionId, evaluation.suggestedMode!, evaluation.reasoning);
+       * }
+       * ```
+       */
+      async evaluateAndSuggestSwitch(sessionId, problemType = "general") {
+        this.logger.debug("Evaluating session for potential mode switch", { sessionId, problemType });
+        const evaluation = this.monitor.evaluateStrategy(sessionId);
+        const session = await this.sessionManager.getSession(sessionId);
+        const currentMode = session?.mode || "sequential" /* SEQUENTIAL */;
+        const alternatives = this.monitor.suggestAlternatives(sessionId, currentMode);
+        const shouldSwitch = evaluation.effectiveness < 0.4 || evaluation.effectiveness < 0.6 && alternatives.length > 0 && alternatives[0].recommendationScore > 0.75;
+        const suggestedMode = shouldSwitch && alternatives.length > 0 ? alternatives[0].mode : void 0;
+        const reasoning = shouldSwitch ? `Current strategy effectiveness: ${(evaluation.effectiveness * 100).toFixed(1)}%. ${alternatives[0]?.reasoning || "Consider switching modes."}` : `Current strategy performing adequately (effectiveness: ${(evaluation.effectiveness * 100).toFixed(1)}%). Continue with current mode.`;
+        this.logger.debug("Mode switch evaluation completed", {
+          sessionId,
+          shouldSwitch,
+          suggestedMode,
+          currentEffectiveness: evaluation.effectiveness
+        });
+        return {
+          currentEvaluation: evaluation,
+          shouldSwitch,
+          suggestedMode,
+          reasoning,
+          alternatives
+        };
+      }
+      /**
+       * Auto-switch mode if current strategy is failing
+       *
+       * Automatically evaluates and switches modes if the current approach
+       * is demonstrably ineffective (effectiveness < 0.3).
+       *
+       * @param sessionId - Session to evaluate
+       * @param problemType - Optional problem type for context
+       * @returns Switch result with details
+       *
+       * @example
+       * ```typescript
+       * const result = await router.autoSwitchIfNeeded('session-123', 'complex-problem');
+       * console.log(result.switched ? 'Switched to' + result.newMode : 'No switch needed');
+       * ```
+       */
+      async autoSwitchIfNeeded(sessionId, problemType = "general") {
+        this.logger.debug("Auto-switch evaluation", { sessionId, problemType });
+        const evaluation = await this.evaluateAndSuggestSwitch(sessionId, problemType);
+        const autoSwitchThreshold = 0.3;
+        if (evaluation.currentEvaluation.effectiveness < autoSwitchThreshold && evaluation.suggestedMode) {
+          const session = await this.sessionManager.getSession(sessionId);
+          const oldMode = session?.mode || "sequential" /* SEQUENTIAL */;
+          await this.switchMode(sessionId, evaluation.suggestedMode, evaluation.reasoning);
+          this.logger.info("Auto-switched mode due to low effectiveness", {
+            sessionId,
+            oldMode,
+            newMode: evaluation.suggestedMode,
+            effectiveness: evaluation.currentEvaluation.effectiveness
+          });
+          return {
+            switched: true,
+            oldMode,
+            newMode: evaluation.suggestedMode,
+            reasoning: evaluation.reasoning,
+            evaluation: evaluation.currentEvaluation
+          };
+        }
+        this.logger.debug("Auto-switch not needed", {
+          sessionId,
+          effectiveness: evaluation.currentEvaluation.effectiveness,
+          threshold: autoSwitchThreshold
+        });
+        return {
+          switched: false,
+          reasoning: evaluation.reasoning,
+          evaluation: evaluation.currentEvaluation
+        };
+      }
     };
   }
 });
@@ -6219,14 +6678,14 @@ var deepthinking_strategic_schema = {
 };
 var deepthinking_analytical_schema = {
   name: "deepthinking_analytical",
-  description: "Analytical: analogical mapping, first principles",
+  description: "Analytical: analogical mapping, first principles, meta-reasoning",
   inputSchema: {
     type: "object",
     properties: {
       ...baseThoughtProperties,
       mode: {
         type: "string",
-        enum: ["analogical", "firstprinciples"],
+        enum: ["analogical", "firstprinciples", "metareasoning"],
         description: "Analytical reasoning mode"
       },
       sourceAnalogy: {
@@ -6758,7 +7217,7 @@ var StrategicSchema = BaseThoughtSchema.extend({
 // src/tools/schemas/modes/analytical.ts
 init_esm_shims();
 var AnalyticalSchema = BaseThoughtSchema.extend({
-  mode: z.enum(["analogical", "firstprinciples"])
+  mode: z.enum(["analogical", "firstprinciples", "metareasoning"])
 });
 
 // src/tools/schemas/modes/scientific.ts
@@ -6805,6 +7264,7 @@ var modeToToolMap = {
   // Analytical modes
   analogical: "deepthinking_analytical",
   firstprinciples: "deepthinking_analytical",
+  metareasoning: "deepthinking_analytical",
   // Scientific modes
   scientificmethod: "deepthinking_scientific",
   systemsthinking: "deepthinking_scientific",