deepthinking-mcp 5.0.0 → 6.0.0

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();
@@ -840,6 +843,57 @@ var init_recommendations = __esm({
        */
       recommendModes(characteristics) {
         const recommendations = [];
+        const isPhilosophical = characteristics.domain.toLowerCase().includes("metaphysics") || characteristics.domain.toLowerCase().includes("theology") || characteristics.domain.toLowerCase().includes("philosophy") || characteristics.domain.toLowerCase().includes("epistemology") || characteristics.domain.toLowerCase().includes("ethics");
+        if (characteristics.complexity === "high" && (characteristics.requiresExplanation || characteristics.hasAlternatives || isPhilosophical)) {
+          recommendations.push({
+            mode: "hybrid" /* HYBRID */,
+            score: 0.92,
+            reasoning: "Complex problem benefits from multi-modal synthesis combining inductive, deductive, and abductive reasoning",
+            strengths: ["Comprehensive analysis", "Combines empirical and logical approaches", "Maximum evidential strength", "Convergent validation"],
+            limitations: ["Time-intensive", "Requires understanding of multiple reasoning types"],
+            examples: ["Philosophical arguments", "Scientific theories", "Complex decision-making", "Metaphysical questions"]
+          });
+        }
+        if (!characteristics.requiresProof && (characteristics.requiresQuantification || characteristics.hasIncompleteInfo || isPhilosophical)) {
+          recommendations.push({
+            mode: "inductive" /* INDUCTIVE */,
+            score: isPhilosophical ? 0.85 : 0.8,
+            reasoning: "Problem requires pattern recognition and generalization from observations",
+            strengths: ["Empirical grounding", "Pattern detection", "Probabilistic reasoning", "Scientific discovery"],
+            limitations: ["Cannot prove with certainty", "Vulnerable to black swans", "Sample size dependent"],
+            examples: ["Scientific hypotheses", "Trend analysis", "Empirical arguments", "Data-driven insights"]
+          });
+        }
+        if (characteristics.requiresProof || isPhilosophical) {
+          recommendations.push({
+            mode: "deductive" /* DEDUCTIVE */,
+            score: characteristics.requiresProof ? 0.9 : 0.75,
+            reasoning: "Problem requires logical derivation from general principles to specific conclusions",
+            strengths: ["Logical validity", "Rigorous inference", "Exposes contradictions", "Formal reasoning"],
+            limitations: ["Soundness depends on premise truth", "Vulnerable to definitional disputes", "May not handle uncertainty well"],
+            examples: ["Logical proofs", "Mathematical theorems", "Philosophical arguments", "Formal verification"]
+          });
+        }
+        if (characteristics.requiresExplanation || isPhilosophical) {
+          recommendations.push({
+            mode: "abductive" /* ABDUCTIVE */,
+            score: isPhilosophical ? 0.9 : 0.87,
+            reasoning: "Problem requires finding best explanations through comparative hypothesis evaluation",
+            strengths: ["Hypothesis generation", "Comparative evaluation", "Explanatory power assessment", "Handles competing theories"],
+            limitations: ["May miss non-obvious explanations", "Explanatory power is subjective"],
+            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 */,
@@ -860,26 +914,16 @@ var init_recommendations = __esm({
             examples: ["Competitive analysis", "Auction design", "Negotiation"]
           });
         }
-        if (characteristics.hasIncompleteInfo && characteristics.uncertainty === "high") {
+        if (characteristics.hasIncompleteInfo && characteristics.uncertainty === "high" && !isPhilosophical) {
           recommendations.push({
             mode: "evidential" /* EVIDENTIAL */,
-            score: 0.88,
-            reasoning: "Problem has incomplete information and high uncertainty",
+            score: 0.82,
+            reasoning: "Problem has incomplete information and high uncertainty requiring Dempster-Shafer belief functions",
             strengths: ["Handles ignorance", "Evidence combination", "Uncertainty intervals"],
-            limitations: ["Computational complexity", "Requires careful mass assignment"],
+            limitations: ["Computational complexity", "Requires careful mass assignment", "Better for sensor fusion than philosophical reasoning"],
             examples: ["Sensor fusion", "Diagnostic reasoning", "Intelligence analysis"]
           });
         }
-        if (characteristics.requiresExplanation) {
-          recommendations.push({
-            mode: "abductive" /* ABDUCTIVE */,
-            score: 0.87,
-            reasoning: "Problem requires finding best explanations",
-            strengths: ["Hypothesis generation", "Root cause analysis", "Explanation quality"],
-            limitations: ["May miss non-obvious explanations"],
-            examples: ["Debugging", "Diagnosis", "Scientific discovery"]
-          });
-        }
         if (characteristics.timeDependent && characteristics.requiresExplanation) {
           recommendations.push({
             mode: "causal" /* CAUSAL */,
@@ -967,6 +1011,16 @@ var init_recommendations = __esm({
        */
       recommendCombinations(characteristics) {
         const combinations = [];
+        const isPhilosophical = characteristics.domain.toLowerCase().includes("metaphysics") || characteristics.domain.toLowerCase().includes("theology") || characteristics.domain.toLowerCase().includes("philosophy") || characteristics.domain.toLowerCase().includes("epistemology") || characteristics.domain.toLowerCase().includes("ethics");
+        if (isPhilosophical || characteristics.complexity === "high" && characteristics.requiresExplanation && characteristics.hasAlternatives) {
+          combinations.push({
+            modes: ["inductive" /* INDUCTIVE */, "deductive" /* DEDUCTIVE */, "abductive" /* ABDUCTIVE */],
+            sequence: "hybrid",
+            rationale: "Synthesize empirical patterns, logical derivations, and explanatory hypotheses for maximum evidential strength",
+            benefits: ["Convergent validation from three independent methods", "Empirical grounding + logical rigor + explanatory power", "Highest achievable confidence through multi-modal synthesis", "Exposes both empirical patterns and logical contradictions"],
+            synergies: ["Inductive patterns inform abductive hypotheses", "Deductive logic tests hypothesis validity", "Abductive explanations guide inductive search", "All three methods converge on same conclusion"]
+          });
+        }
         if (characteristics.timeDependent && characteristics.requiresExplanation) {
           combinations.push({
             modes: ["temporal" /* TEMPORAL */, "causal" /* CAUSAL */],
@@ -1012,15 +1066,6 @@ var init_recommendations = __esm({
             synergies: ["Temporal events as game stages", "Strategies evolve over timeline"]
           });
         }
-        if (characteristics.requiresExplanation && characteristics.complexity === "high") {
-          combinations.push({
-            modes: ["analogical" /* ANALOGICAL */, "abductive" /* ABDUCTIVE */],
-            sequence: "parallel",
-            rationale: "Use analogies to inspire hypotheses while systematically generating explanations",
-            benefits: ["Creative hypothesis generation", "Cross-domain insights"],
-            synergies: ["Analogies suggest hypotheses", "Hypotheses validated by analogical reasoning"]
-          });
-        }
         if (characteristics.requiresProof && characteristics.complexity === "high") {
           combinations.push({
             modes: ["shannon" /* SHANNON */, "mathematics" /* MATHEMATICS */],
@@ -1038,8 +1083,28 @@ var init_recommendations = __esm({
        */
       quickRecommend(problemType) {
         const typeMap = {
+          // Core reasoning modes
+          "explanation": "abductive" /* ABDUCTIVE */,
+          "hypothesis": "abductive" /* ABDUCTIVE */,
+          "inference": "abductive" /* ABDUCTIVE */,
+          "pattern": "inductive" /* INDUCTIVE */,
+          "generalization": "inductive" /* INDUCTIVE */,
+          "empirical": "inductive" /* INDUCTIVE */,
+          "logic": "deductive" /* DEDUCTIVE */,
+          "proof": "deductive" /* DEDUCTIVE */,
+          "derivation": "deductive" /* DEDUCTIVE */,
+          "complex": "hybrid" /* HYBRID */,
+          "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 */,
-          "proof": "mathematics" /* MATHEMATICS */,
+          "mathematical": "mathematics" /* MATHEMATICS */,
           "timeline": "temporal" /* TEMPORAL */,
           "strategy": "gametheory" /* GAMETHEORY */,
           "uncertainty": "evidential" /* EVIDENTIAL */,
@@ -1923,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"() {
@@ -1932,6 +2209,7 @@ var init_manager = __esm({
     init_logger();
     init_lru();
     init_SessionMetricsCalculator();
+    init_MetaMonitor();
     DEFAULT_CONFIG2 = {
       modeConfig: {
         mode: "hybrid" /* HYBRID */,
@@ -1953,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
@@ -1980,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,
@@ -1993,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 {
@@ -2062,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,
@@ -2145,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", {
@@ -2640,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 {
@@ -4935,6 +5273,7 @@ var ExportService;
 var init_ExportService = __esm({
   "src/services/ExportService.ts"() {
     init_esm_shims();
+    init_types();
     init_visual();
     init_sanitization();
     init_logger();
@@ -5115,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;
       }
@@ -5273,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
@@ -5454,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
+        };
+      }
     };
   }
 });
@@ -6172,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: {
@@ -6711,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
@@ -6758,6 +7264,7 @@ var modeToToolMap = {
   // Analytical modes
   analogical: "deepthinking_analytical",
   firstprinciples: "deepthinking_analytical",
+  metareasoning: "deepthinking_analytical",
   // Scientific modes
   scientificmethod: "deepthinking_scientific",
   systemsthinking: "deepthinking_scientific",