deepthinking-mcp 5.0.1 → 6.1.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();
@@ -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 {
@@ -4907,90 +5198,1206 @@ var init_formal_logic = __esm({
   }
 });
 
-// src/export/visual/index.ts
-var VisualExporter;
-var init_visual = __esm({
-  "src/export/visual/index.ts"() {
-    init_esm_shims();
-    init_causal();
-    init_temporal();
-    init_game_theory();
-    init_bayesian();
-    init_sequential();
-    init_shannon();
-    init_abductive();
-    init_counterfactual();
-    init_analogical();
-    init_evidential();
-    init_first_principles();
-    init_systems_thinking();
-    init_scientific_method();
-    init_optimization();
-    init_formal_logic();
-    VisualExporter = class {
-      exportCausalGraph(thought, options) {
-        return exportCausalGraph(thought, options);
-      }
-      exportTemporalTimeline(thought, options) {
-        return exportTemporalTimeline(thought, options);
-      }
-      exportGameTree(thought, options) {
-        return exportGameTree(thought, options);
-      }
-      exportBayesianNetwork(thought, options) {
-        return exportBayesianNetwork(thought, options);
-      }
-      exportSequentialDependencyGraph(thought, options) {
-        return exportSequentialDependencyGraph(thought, options);
-      }
-      exportShannonStageFlow(thought, options) {
-        return exportShannonStageFlow(thought, options);
-      }
-      exportAbductiveHypotheses(thought, options) {
-        return exportAbductiveHypotheses(thought, options);
-      }
-      exportCounterfactualScenarios(thought, options) {
-        return exportCounterfactualScenarios(thought, options);
-      }
-      exportAnalogicalMapping(thought, options) {
-        return exportAnalogicalMapping(thought, options);
-      }
-      exportEvidentialBeliefs(thought, options) {
-        return exportEvidentialBeliefs(thought, options);
-      }
-      exportFirstPrinciplesDerivation(thought, options) {
-        return exportFirstPrinciplesDerivation(thought, options);
-      }
-      exportSystemsThinkingCausalLoops(thought, options) {
-        return exportSystemsThinkingCausalLoops(thought, options);
-      }
-      exportScientificMethodExperiment(thought, options) {
-        return exportScientificMethodExperiment(thought, options);
-      }
-      exportOptimizationSolution(thought, options) {
-        return exportOptimizationSolution(thought, options);
-      }
-      exportFormalLogicProof(thought, options) {
-        return exportFormalLogicProof(thought, options);
+// src/export/visual/mathematics.ts
+function exportMathematicsDerivation(thought, options) {
+  const { format, colorScheme = "default", includeLabels = true, includeMetrics = true } = options;
+  switch (format) {
+    case "mermaid":
+      return mathematicsToMermaid(thought, colorScheme, includeLabels, includeMetrics);
+    case "dot":
+      return mathematicsToDOT(thought, includeLabels, includeMetrics);
+    case "ascii":
+      return mathematicsToASCII(thought);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function mathematicsToMermaid(thought, colorScheme, includeLabels, includeMetrics) {
+  let mermaid = "graph TB\n";
+  const typeId = sanitizeId(`type_${thought.thoughtType || "proof"}`);
+  const typeLabel = includeLabels ? (thought.thoughtType || "Proof").replace(/_/g, " ") : typeId;
+  mermaid += `  ${typeId}[["${typeLabel}"]]
+`;
+  if (thought.proofStrategy) {
+    const strategyId = sanitizeId("strategy");
+    const strategyLabel = thought.proofStrategy.type;
+    mermaid += `  ${strategyId}(["${strategyLabel}"])
+`;
+    mermaid += `  ${typeId} --> ${strategyId}
+`;
+    let prevStepId = strategyId;
+    thought.proofStrategy.steps.forEach((step, index) => {
+      const stepId = sanitizeId(`step_${index}`);
+      const stepLabel = includeLabels ? step.slice(0, 40) + (step.length > 40 ? "..." : "") : `Step ${index + 1}`;
+      mermaid += `  ${stepId}["${stepLabel}"]
+`;
+      mermaid += `  ${prevStepId} --> ${stepId}
+`;
+      prevStepId = stepId;
+    });
+    if (includeMetrics) {
+      const completenessId = sanitizeId("completeness");
+      const completenessLabel = `Completeness: ${(thought.proofStrategy.completeness * 100).toFixed(0)}%`;
+      mermaid += `  ${completenessId}{{${completenessLabel}}}
+`;
+      mermaid += `  ${prevStepId} --> ${completenessId}
+`;
+    }
+  }
+  if (thought.mathematicalModel) {
+    const modelId = sanitizeId("model");
+    const modelLabel = thought.mathematicalModel.symbolic || "Mathematical Model";
+    mermaid += `  ${modelId}["${modelLabel}"]
+`;
+    mermaid += `  ${typeId} --> ${modelId}
+`;
+  }
+  if (thought.theorems && thought.theorems.length > 0) {
+    thought.theorems.forEach((theorem, index) => {
+      const theoremId = sanitizeId(`theorem_${index}`);
+      const theoremLabel = theorem.name || `Theorem ${index + 1}`;
+      mermaid += `  ${theoremId}[/"${theoremLabel}"/]
+`;
+      mermaid += `  ${typeId} --> ${theoremId}
+`;
+    });
+  }
+  if (thought.assumptions && thought.assumptions.length > 0) {
+    const assumptionsId = sanitizeId("assumptions");
+    mermaid += `  ${assumptionsId}>"Assumptions: ${thought.assumptions.length}"]
+`;
+  }
+  if (colorScheme !== "monochrome") {
+    const colors = colorScheme === "pastel" ? { type: "#e8f4e8", strategy: "#fff3e0"} : { type: "#90EE90", strategy: "#FFD700"};
+    mermaid += `
+  style ${typeId} fill:${colors.type}
+`;
+    if (thought.proofStrategy) {
+      mermaid += `  style ${sanitizeId("strategy")} fill:${colors.strategy}
+`;
+    }
+  }
+  return mermaid;
+}
+function mathematicsToDOT(thought, includeLabels, includeMetrics) {
+  let dot = "digraph MathematicsDerivation {\n";
+  dot += "  rankdir=TB;\n";
+  dot += "  node [shape=box, style=rounded];\n\n";
+  const typeId = sanitizeId(`type_${thought.thoughtType || "proof"}`);
+  const typeLabel = includeLabels ? (thought.thoughtType || "Proof").replace(/_/g, " ") : typeId;
+  dot += `  ${typeId} [label="${typeLabel}", shape=doubleoctagon];
+`;
+  if (thought.proofStrategy) {
+    const strategyId = sanitizeId("strategy");
+    dot += `  ${strategyId} [label="${thought.proofStrategy.type}", shape=ellipse];
+`;
+    dot += `  ${typeId} -> ${strategyId};
+`;
+    let prevStepId = strategyId;
+    thought.proofStrategy.steps.forEach((step, index) => {
+      const stepId = sanitizeId(`step_${index}`);
+      const stepLabel = includeLabels ? step.slice(0, 30).replace(/"/g, '\\"') : `Step ${index + 1}`;
+      dot += `  ${stepId} [label="${stepLabel}"];
+`;
+      dot += `  ${prevStepId} -> ${stepId};
+`;
+      prevStepId = stepId;
+    });
+    if (includeMetrics) {
+      const completenessId = sanitizeId("completeness");
+      dot += `  ${completenessId} [label="${(thought.proofStrategy.completeness * 100).toFixed(0)}%", shape=diamond];
+`;
+      dot += `  ${prevStepId} -> ${completenessId};
+`;
+    }
+  }
+  if (thought.theorems) {
+    thought.theorems.forEach((theorem, index) => {
+      const theoremId = sanitizeId(`theorem_${index}`);
+      dot += `  ${theoremId} [label="${theorem.name || `Theorem ${index + 1}`}", shape=parallelogram];
+`;
+      dot += `  ${typeId} -> ${theoremId};
+`;
+    });
+  }
+  dot += "}\n";
+  return dot;
+}
+function mathematicsToASCII(thought) {
+  let ascii = "Mathematics Derivation:\n";
+  ascii += "=======================\n\n";
+  ascii += `Type: ${(thought.thoughtType || "proof").replace(/_/g, " ")}
+`;
+  ascii += `Uncertainty: ${(thought.uncertainty * 100).toFixed(1)}%
+
+`;
+  if (thought.mathematicalModel) {
+    ascii += "Mathematical Model:\n";
+    ascii += `  LaTeX: ${thought.mathematicalModel.latex}
+`;
+    ascii += `  Symbolic: ${thought.mathematicalModel.symbolic}
+`;
+    if (thought.mathematicalModel.ascii) {
+      ascii += `  ASCII: ${thought.mathematicalModel.ascii}
+`;
+    }
+    ascii += "\n";
+  }
+  if (thought.proofStrategy) {
+    ascii += `Proof Strategy: ${thought.proofStrategy.type}
+`;
+    ascii += `Completeness: ${(thought.proofStrategy.completeness * 100).toFixed(0)}%
+`;
+    ascii += "Steps:\n";
+    thought.proofStrategy.steps.forEach((step, index) => {
+      ascii += `  ${index + 1}. ${step}
+`;
+    });
+    if (thought.proofStrategy.baseCase) {
+      ascii += `Base Case: ${thought.proofStrategy.baseCase}
+`;
+    }
+    if (thought.proofStrategy.inductiveStep) {
+      ascii += `Inductive Step: ${thought.proofStrategy.inductiveStep}
+`;
+    }
+    ascii += "\n";
+  }
+  if (thought.theorems && thought.theorems.length > 0) {
+    ascii += "Theorems:\n";
+    thought.theorems.forEach((theorem, index) => {
+      ascii += `  [${index + 1}] ${theorem.name}: ${theorem.statement}
+`;
+      if (theorem.hypotheses.length > 0) {
+        ascii += `      Hypotheses: ${theorem.hypotheses.join(", ")}
+`;
       }
-    };
+      ascii += `      Conclusion: ${theorem.conclusion}
+`;
+    });
+    ascii += "\n";
+  }
+  if (thought.assumptions && thought.assumptions.length > 0) {
+    ascii += "Assumptions:\n";
+    thought.assumptions.forEach((assumption, index) => {
+      ascii += `  ${index + 1}. ${assumption}
+`;
+    });
+    ascii += "\n";
+  }
+  if (thought.dependencies && thought.dependencies.length > 0) {
+    ascii += "Dependencies:\n";
+    thought.dependencies.forEach((dep, index) => {
+      ascii += `  ${index + 1}. ${dep}
+`;
+    });
+  }
+  return ascii;
+}
+var init_mathematics = __esm({
+  "src/export/visual/mathematics.ts"() {
+    init_esm_shims();
+    init_utils();
   }
 });
 
-// src/services/ExportService.ts
-var ExportService;
-var init_ExportService = __esm({
-  "src/services/ExportService.ts"() {
-    init_esm_shims();
-    init_visual();
-    init_sanitization();
-    init_logger();
-    ExportService = class {
-      visualExporter;
-      logger;
-      constructor(logger2) {
-        this.visualExporter = new VisualExporter();
-        this.logger = logger2 || createLogger({ minLevel: 1 /* INFO */, enableConsole: true });
+// src/export/visual/physics.ts
+function exportPhysicsVisualization(thought, options) {
+  const { format, colorScheme = "default", includeLabels = true, includeMetrics = true } = options;
+  switch (format) {
+    case "mermaid":
+      return physicsToMermaid(thought, colorScheme, includeLabels, includeMetrics);
+    case "dot":
+      return physicsToDOT(thought, includeLabels, includeMetrics);
+    case "ascii":
+      return physicsToASCII(thought);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function physicsToMermaid(thought, colorScheme, includeLabels, includeMetrics) {
+  let mermaid = "graph TB\n";
+  const typeId = sanitizeId(`type_${thought.thoughtType || "physics"}`);
+  const typeLabel = includeLabels ? (thought.thoughtType || "Physics").replace(/_/g, " ") : typeId;
+  mermaid += `  ${typeId}[["${typeLabel}"]]
+`;
+  if (thought.tensorProperties) {
+    const tensorId = sanitizeId("tensor");
+    const rankLabel = `Rank (${thought.tensorProperties.rank[0]},${thought.tensorProperties.rank[1]})`;
+    mermaid += `  ${tensorId}(["${rankLabel}"])
+`;
+    mermaid += `  ${typeId} --> ${tensorId}
+`;
+    const compId = sanitizeId("components");
+    const compLabel = includeLabels ? thought.tensorProperties.components.slice(0, 30) + (thought.tensorProperties.components.length > 30 ? "..." : "") : "Components";
+    mermaid += `  ${compId}["${compLabel}"]
+`;
+    mermaid += `  ${tensorId} --> ${compId}
+`;
+    if (thought.tensorProperties.symmetries.length > 0) {
+      const symId = sanitizeId("symmetries");
+      mermaid += `  ${symId}{{"Symmetries: ${thought.tensorProperties.symmetries.length}"}}
+`;
+      mermaid += `  ${tensorId} --> ${symId}
+`;
+    }
+    if (thought.tensorProperties.invariants.length > 0) {
+      const invId = sanitizeId("invariants");
+      mermaid += `  ${invId}{{"Invariants: ${thought.tensorProperties.invariants.length}"}}
+`;
+      mermaid += `  ${tensorId} --> ${invId}
+`;
+    }
+  }
+  if (thought.physicalInterpretation) {
+    const interpId = sanitizeId("interpretation");
+    const interpLabel = thought.physicalInterpretation.quantity;
+    mermaid += `  ${interpId}[/"${interpLabel}"/]
+`;
+    mermaid += `  ${typeId} --> ${interpId}
+`;
+    const unitsId = sanitizeId("units");
+    mermaid += `  ${unitsId}(["${thought.physicalInterpretation.units}"])
+`;
+    mermaid += `  ${interpId} --> ${unitsId}
+`;
+    if (thought.physicalInterpretation.conservationLaws.length > 0) {
+      thought.physicalInterpretation.conservationLaws.forEach((law, index) => {
+        const lawId = sanitizeId(`conservation_${index}`);
+        const lawLabel = includeLabels ? law.slice(0, 25) + (law.length > 25 ? "..." : "") : `Law ${index + 1}`;
+        mermaid += `  ${lawId}>"${lawLabel}"]
+`;
+        mermaid += `  ${interpId} --> ${lawId}
+`;
+      });
+    }
+  }
+  if (thought.fieldTheoryContext) {
+    const fieldId = sanitizeId("field_theory");
+    mermaid += `  ${fieldId}[("Field Theory")]
+`;
+    mermaid += `  ${typeId} --> ${fieldId}
+`;
+    thought.fieldTheoryContext.fields.forEach((field, index) => {
+      const fId = sanitizeId(`field_${index}`);
+      mermaid += `  ${fId}["${field}"]
+`;
+      mermaid += `  ${fieldId} --> ${fId}
+`;
+    });
+    const symGroupId = sanitizeId("symmetry_group");
+    mermaid += `  ${symGroupId}{{"${thought.fieldTheoryContext.symmetryGroup}"}}
+`;
+    mermaid += `  ${fieldId} --> ${symGroupId}
+`;
+  }
+  if (includeMetrics) {
+    const uncertId = sanitizeId("uncertainty");
+    const uncertLabel = `Uncertainty: ${(thought.uncertainty * 100).toFixed(1)}%`;
+    mermaid += `  ${uncertId}{{${uncertLabel}}}
+`;
+  }
+  if (thought.assumptions && thought.assumptions.length > 0) {
+    const assumptionsId = sanitizeId("assumptions");
+    mermaid += `  ${assumptionsId}>"Assumptions: ${thought.assumptions.length}"]
+`;
+  }
+  if (colorScheme !== "monochrome") {
+    const colors = colorScheme === "pastel" ? { type: "#e3f2fd", tensor: "#fff3e0", interp: "#e8f5e9" } : { type: "#87CEEB", tensor: "#FFD700", interp: "#90EE90" };
+    mermaid += `
+  style ${typeId} fill:${colors.type}
+`;
+    if (thought.tensorProperties) {
+      mermaid += `  style ${sanitizeId("tensor")} fill:${colors.tensor}
+`;
+    }
+    if (thought.physicalInterpretation) {
+      mermaid += `  style ${sanitizeId("interpretation")} fill:${colors.interp}
+`;
+    }
+  }
+  return mermaid;
+}
+function physicsToDOT(thought, includeLabels, includeMetrics) {
+  let dot = "digraph PhysicsVisualization {\n";
+  dot += "  rankdir=TB;\n";
+  dot += "  node [shape=box, style=rounded];\n\n";
+  const typeId = sanitizeId(`type_${thought.thoughtType || "physics"}`);
+  const typeLabel = includeLabels ? (thought.thoughtType || "Physics").replace(/_/g, " ") : typeId;
+  dot += `  ${typeId} [label="${typeLabel}", shape=doubleoctagon];
+`;
+  if (thought.tensorProperties) {
+    const tensorId = sanitizeId("tensor");
+    const rankLabel = `Rank (${thought.tensorProperties.rank[0]},${thought.tensorProperties.rank[1]})`;
+    dot += `  ${tensorId} [label="${rankLabel}", shape=ellipse];
+`;
+    dot += `  ${typeId} -> ${tensorId};
+`;
+    const compId = sanitizeId("components");
+    const compLabel = includeLabels ? thought.tensorProperties.components.slice(0, 25).replace(/"/g, '\\"') : "Components";
+    dot += `  ${compId} [label="${compLabel}"];
+`;
+    dot += `  ${tensorId} -> ${compId};
+`;
+    const transId = sanitizeId("transformation");
+    dot += `  ${transId} [label="${thought.tensorProperties.transformation}", shape=diamond];
+`;
+    dot += `  ${tensorId} -> ${transId};
+`;
+  }
+  if (thought.physicalInterpretation) {
+    const interpId = sanitizeId("interpretation");
+    dot += `  ${interpId} [label="${thought.physicalInterpretation.quantity}", shape=parallelogram];
+`;
+    dot += `  ${typeId} -> ${interpId};
+`;
+    const unitsId = sanitizeId("units");
+    dot += `  ${unitsId} [label="${thought.physicalInterpretation.units}", shape=ellipse];
+`;
+    dot += `  ${interpId} -> ${unitsId};
+`;
+    thought.physicalInterpretation.conservationLaws.forEach((law, index) => {
+      const lawId = sanitizeId(`conservation_${index}`);
+      const lawLabel = includeLabels ? law.slice(0, 20).replace(/"/g, '\\"') : `Law ${index + 1}`;
+      dot += `  ${lawId} [label="${lawLabel}", shape=hexagon];
+`;
+      dot += `  ${interpId} -> ${lawId};
+`;
+    });
+  }
+  if (thought.fieldTheoryContext) {
+    const fieldId = sanitizeId("field_theory");
+    dot += `  ${fieldId} [label="Field Theory", shape=cylinder];
+`;
+    dot += `  ${typeId} -> ${fieldId};
+`;
+    thought.fieldTheoryContext.fields.forEach((field, index) => {
+      const fId = sanitizeId(`field_${index}`);
+      dot += `  ${fId} [label="${field}"];
+`;
+      dot += `  ${fieldId} -> ${fId};
+`;
+    });
+    const symGroupId = sanitizeId("symmetry_group");
+    dot += `  ${symGroupId} [label="${thought.fieldTheoryContext.symmetryGroup}", shape=diamond];
+`;
+    dot += `  ${fieldId} -> ${symGroupId};
+`;
+  }
+  if (includeMetrics) {
+    const uncertId = sanitizeId("uncertainty");
+    dot += `  ${uncertId} [label="${(thought.uncertainty * 100).toFixed(1)}%", shape=diamond];
+`;
+  }
+  dot += "}\n";
+  return dot;
+}
+function physicsToASCII(thought) {
+  let ascii = "Physics Analysis:\n";
+  ascii += "=================\n\n";
+  ascii += `Type: ${(thought.thoughtType || "physics").replace(/_/g, " ")}
+`;
+  ascii += `Uncertainty: ${(thought.uncertainty * 100).toFixed(1)}%
+
+`;
+  if (thought.tensorProperties) {
+    ascii += "Tensor Properties:\n";
+    ascii += `  Rank: (${thought.tensorProperties.rank[0]}, ${thought.tensorProperties.rank[1]})
+`;
+    ascii += `  Components: ${thought.tensorProperties.components}
+`;
+    ascii += `  LaTeX: ${thought.tensorProperties.latex}
+`;
+    ascii += `  Transformation: ${thought.tensorProperties.transformation}
+`;
+    if (thought.tensorProperties.indexStructure) {
+      ascii += `  Index Structure: ${thought.tensorProperties.indexStructure}
+`;
+    }
+    if (thought.tensorProperties.coordinateSystem) {
+      ascii += `  Coordinate System: ${thought.tensorProperties.coordinateSystem}
+`;
+    }
+    if (thought.tensorProperties.symmetries.length > 0) {
+      ascii += "  Symmetries:\n";
+      thought.tensorProperties.symmetries.forEach((sym, index) => {
+        ascii += `    ${index + 1}. ${sym}
+`;
+      });
+    }
+    if (thought.tensorProperties.invariants.length > 0) {
+      ascii += "  Invariants:\n";
+      thought.tensorProperties.invariants.forEach((inv, index) => {
+        ascii += `    ${index + 1}. ${inv}
+`;
+      });
+    }
+    ascii += "\n";
+  }
+  if (thought.physicalInterpretation) {
+    ascii += "Physical Interpretation:\n";
+    ascii += `  Quantity: ${thought.physicalInterpretation.quantity}
+`;
+    ascii += `  Units: ${thought.physicalInterpretation.units}
+`;
+    if (thought.physicalInterpretation.conservationLaws.length > 0) {
+      ascii += "  Conservation Laws:\n";
+      thought.physicalInterpretation.conservationLaws.forEach((law, index) => {
+        ascii += `    ${index + 1}. ${law}
+`;
+      });
+    }
+    if (thought.physicalInterpretation.constraints && thought.physicalInterpretation.constraints.length > 0) {
+      ascii += "  Constraints:\n";
+      thought.physicalInterpretation.constraints.forEach((constraint, index) => {
+        ascii += `    ${index + 1}. ${constraint}
+`;
+      });
+    }
+    if (thought.physicalInterpretation.observables && thought.physicalInterpretation.observables.length > 0) {
+      ascii += "  Observables:\n";
+      thought.physicalInterpretation.observables.forEach((obs, index) => {
+        ascii += `    ${index + 1}. ${obs}
+`;
+      });
+    }
+    ascii += "\n";
+  }
+  if (thought.fieldTheoryContext) {
+    ascii += "Field Theory Context:\n";
+    ascii += `  Symmetry Group: ${thought.fieldTheoryContext.symmetryGroup}
+`;
+    if (thought.fieldTheoryContext.fields.length > 0) {
+      ascii += "  Fields:\n";
+      thought.fieldTheoryContext.fields.forEach((field, index) => {
+        ascii += `    ${index + 1}. ${field}
+`;
+      });
+    }
+    if (thought.fieldTheoryContext.interactions.length > 0) {
+      ascii += "  Interactions:\n";
+      thought.fieldTheoryContext.interactions.forEach((interaction, index) => {
+        ascii += `    ${index + 1}. ${interaction}
+`;
+      });
+    }
+    if (thought.fieldTheoryContext.gaugeSymmetries && thought.fieldTheoryContext.gaugeSymmetries.length > 0) {
+      ascii += "  Gauge Symmetries:\n";
+      thought.fieldTheoryContext.gaugeSymmetries.forEach((gauge, index) => {
+        ascii += `    ${index + 1}. ${gauge}
+`;
+      });
+    }
+    ascii += "\n";
+  }
+  if (thought.assumptions && thought.assumptions.length > 0) {
+    ascii += "Assumptions:\n";
+    thought.assumptions.forEach((assumption, index) => {
+      ascii += `  ${index + 1}. ${assumption}
+`;
+    });
+    ascii += "\n";
+  }
+  if (thought.dependencies && thought.dependencies.length > 0) {
+    ascii += "Dependencies:\n";
+    thought.dependencies.forEach((dep, index) => {
+      ascii += `  ${index + 1}. ${dep}
+`;
+    });
+  }
+  return ascii;
+}
+var init_physics = __esm({
+  "src/export/visual/physics.ts"() {
+    init_esm_shims();
+    init_utils();
+  }
+});
+
+// src/export/visual/hybrid.ts
+function exportHybridOrchestration(thought, options) {
+  const { format, colorScheme = "default", includeLabels = true, includeMetrics = true } = options;
+  switch (format) {
+    case "mermaid":
+      return hybridToMermaid(thought, colorScheme, includeLabels, includeMetrics);
+    case "dot":
+      return hybridToDOT(thought, includeLabels, includeMetrics);
+    case "ascii":
+      return hybridToASCII(thought);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function hybridToMermaid(thought, colorScheme, includeLabels, includeMetrics) {
+  let mermaid = "graph TB\n";
+  const hybridId = sanitizeId("hybrid_mode");
+  mermaid += `  ${hybridId}(("Hybrid Mode"))
+`;
+  const primaryId = sanitizeId(`primary_${thought.primaryMode}`);
+  const primaryLabel = includeLabels ? thought.primaryMode.charAt(0).toUpperCase() + thought.primaryMode.slice(1) : primaryId;
+  mermaid += `  ${primaryId}[["${primaryLabel}"]]
+`;
+  mermaid += `  ${hybridId} ==> ${primaryId}
+`;
+  if (thought.secondaryFeatures && thought.secondaryFeatures.length > 0) {
+    const secondaryId = sanitizeId("secondary_features");
+    mermaid += `  ${secondaryId}(["Secondary Features"])
+`;
+    mermaid += `  ${hybridId} --> ${secondaryId}
+`;
+    thought.secondaryFeatures.forEach((feature, index) => {
+      const featureId = sanitizeId(`feature_${index}`);
+      const featureLabel = includeLabels ? feature.slice(0, 30) + (feature.length > 30 ? "..." : "") : `Feature ${index + 1}`;
+      mermaid += `  ${featureId}["${featureLabel}"]
+`;
+      mermaid += `  ${secondaryId} --> ${featureId}
+`;
+    });
+  }
+  if (thought.switchReason) {
+    const switchId = sanitizeId("switch_reason");
+    const switchLabel = includeLabels ? thought.switchReason.slice(0, 40) + (thought.switchReason.length > 40 ? "..." : "") : "Switch Reason";
+    mermaid += `  ${switchId}>"${switchLabel}"]
+`;
+    mermaid += `  ${hybridId} -.-> ${switchId}
+`;
+  }
+  if (thought.stage) {
+    const stageId = sanitizeId(`stage_${thought.stage}`);
+    const stageLabel = thought.stage.replace(/_/g, " ");
+    mermaid += `  ${stageId}{{"Stage: ${stageLabel}"}}
+`;
+    mermaid += `  ${primaryId} --> ${stageId}
+`;
+  }
+  if (thought.mathematicalModel) {
+    const modelId = sanitizeId("math_model");
+    const modelLabel = thought.mathematicalModel.symbolic || "Mathematical Model";
+    mermaid += `  ${modelId}["${modelLabel}"]
+`;
+    mermaid += `  ${primaryId} --> ${modelId}
+`;
+  }
+  if (thought.tensorProperties) {
+    const tensorId = sanitizeId("tensor");
+    const tensorLabel = `Tensor (${thought.tensorProperties.rank[0]},${thought.tensorProperties.rank[1]})`;
+    mermaid += `  ${tensorId}[/"${tensorLabel}"/]
+`;
+    mermaid += `  ${primaryId} --> ${tensorId}
+`;
+  }
+  if (thought.physicalInterpretation) {
+    const physId = sanitizeId("physical");
+    mermaid += `  ${physId}[/"${thought.physicalInterpretation.quantity}"/]
+`;
+    mermaid += `  ${primaryId} --> ${physId}
+`;
+  }
+  if (includeMetrics && thought.uncertainty !== void 0) {
+    const uncertId = sanitizeId("uncertainty");
+    const uncertLabel = `Uncertainty: ${(thought.uncertainty * 100).toFixed(1)}%`;
+    mermaid += `  ${uncertId}{{${uncertLabel}}}
+`;
+  }
+  if (thought.assumptions && thought.assumptions.length > 0) {
+    const assumptionsId = sanitizeId("assumptions");
+    mermaid += `  ${assumptionsId}>"Assumptions: ${thought.assumptions.length}"]
+`;
+  }
+  if (thought.dependencies && thought.dependencies.length > 0) {
+    const depsId = sanitizeId("dependencies");
+    mermaid += `  ${depsId}>"Dependencies: ${thought.dependencies.length}"]
+`;
+  }
+  if (colorScheme !== "monochrome") {
+    const colors = colorScheme === "pastel" ? { hybrid: "#e8f4e8", primary: "#e3f2fd", secondary: "#fff3e0" } : { hybrid: "#90EE90", primary: "#87CEEB", secondary: "#FFD700" };
+    mermaid += `
+  style ${hybridId} fill:${colors.hybrid}
+`;
+    mermaid += `  style ${primaryId} fill:${colors.primary}
+`;
+    if (thought.secondaryFeatures && thought.secondaryFeatures.length > 0) {
+      mermaid += `  style ${sanitizeId("secondary_features")} fill:${colors.secondary}
+`;
+    }
+  }
+  return mermaid;
+}
+function hybridToDOT(thought, includeLabels, includeMetrics) {
+  let dot = "digraph HybridOrchestration {\n";
+  dot += "  rankdir=TB;\n";
+  dot += "  node [shape=box, style=rounded];\n\n";
+  const hybridId = sanitizeId("hybrid_mode");
+  dot += `  ${hybridId} [label="Hybrid Mode", shape=doubleoctagon];
+`;
+  const primaryId = sanitizeId(`primary_${thought.primaryMode}`);
+  const primaryLabel = thought.primaryMode.charAt(0).toUpperCase() + thought.primaryMode.slice(1);
+  dot += `  ${primaryId} [label="${primaryLabel}", shape=box, style="filled,rounded", fillcolor=lightblue];
+`;
+  dot += `  ${hybridId} -> ${primaryId} [style=bold, penwidth=2];
+`;
+  if (thought.secondaryFeatures && thought.secondaryFeatures.length > 0) {
+    const secondaryId = sanitizeId("secondary_features");
+    dot += `  ${secondaryId} [label="Secondary Features", shape=ellipse];
+`;
+    dot += `  ${hybridId} -> ${secondaryId};
+`;
+    thought.secondaryFeatures.forEach((feature, index) => {
+      const featureId = sanitizeId(`feature_${index}`);
+      const featureLabel = includeLabels ? feature.slice(0, 25).replace(/"/g, '\\"') : `Feature ${index + 1}`;
+      dot += `  ${featureId} [label="${featureLabel}"];
+`;
+      dot += `  ${secondaryId} -> ${featureId};
+`;
+    });
+  }
+  if (thought.switchReason) {
+    const switchId = sanitizeId("switch_reason");
+    const switchLabel = includeLabels ? thought.switchReason.slice(0, 30).replace(/"/g, '\\"') : "Switch Reason";
+    dot += `  ${switchId} [label="${switchLabel}", shape=note];
+`;
+    dot += `  ${hybridId} -> ${switchId} [style=dashed];
+`;
+  }
+  if (thought.stage) {
+    const stageId = sanitizeId(`stage_${thought.stage}`);
+    dot += `  ${stageId} [label="${thought.stage.replace(/_/g, " ")}", shape=diamond];
+`;
+    dot += `  ${primaryId} -> ${stageId};
+`;
+  }
+  if (thought.mathematicalModel) {
+    const modelId = sanitizeId("math_model");
+    const modelLabel = thought.mathematicalModel.symbolic ? thought.mathematicalModel.symbolic.slice(0, 25).replace(/"/g, '\\"') : "Math Model";
+    dot += `  ${modelId} [label="${modelLabel}", shape=parallelogram];
+`;
+    dot += `  ${primaryId} -> ${modelId};
+`;
+  }
+  if (thought.tensorProperties) {
+    const tensorId = sanitizeId("tensor");
+    dot += `  ${tensorId} [label="Tensor (${thought.tensorProperties.rank[0]},${thought.tensorProperties.rank[1]})", shape=parallelogram];
+`;
+    dot += `  ${primaryId} -> ${tensorId};
+`;
+  }
+  if (thought.physicalInterpretation) {
+    const physId = sanitizeId("physical");
+    dot += `  ${physId} [label="${thought.physicalInterpretation.quantity}", shape=parallelogram];
+`;
+    dot += `  ${primaryId} -> ${physId};
+`;
+  }
+  if (includeMetrics && thought.uncertainty !== void 0) {
+    const uncertId = sanitizeId("uncertainty");
+    dot += `  ${uncertId} [label="${(thought.uncertainty * 100).toFixed(1)}%", shape=diamond];
+`;
+  }
+  dot += "}\n";
+  return dot;
+}
+function hybridToASCII(thought) {
+  let ascii = "Hybrid Mode Orchestration:\n";
+  ascii += "==========================\n\n";
+  ascii += `Primary Mode: ${thought.primaryMode.charAt(0).toUpperCase() + thought.primaryMode.slice(1)}
+`;
+  if (thought.stage) {
+    ascii += `Current Stage: ${thought.stage.replace(/_/g, " ")}
+`;
+  }
+  if (thought.uncertainty !== void 0) {
+    ascii += `Uncertainty: ${(thought.uncertainty * 100).toFixed(1)}%
+`;
+  }
+  ascii += "\n";
+  if (thought.switchReason) {
+    ascii += `Switch Reason: ${thought.switchReason}
+
+`;
+  }
+  if (thought.secondaryFeatures && thought.secondaryFeatures.length > 0) {
+    ascii += "Secondary Features:\n";
+    thought.secondaryFeatures.forEach((feature, index) => {
+      ascii += `  ${index + 1}. ${feature}
+`;
+    });
+    ascii += "\n";
+  }
+  if (thought.mathematicalModel) {
+    ascii += "Mathematical Model:\n";
+    ascii += `  LaTeX: ${thought.mathematicalModel.latex}
+`;
+    ascii += `  Symbolic: ${thought.mathematicalModel.symbolic}
+`;
+    if (thought.mathematicalModel.ascii) {
+      ascii += `  ASCII: ${thought.mathematicalModel.ascii}
+`;
+    }
+    ascii += "\n";
+  }
+  if (thought.tensorProperties) {
+    ascii += "Tensor Properties:\n";
+    ascii += `  Rank: (${thought.tensorProperties.rank[0]}, ${thought.tensorProperties.rank[1]})
+`;
+    ascii += `  Components: ${thought.tensorProperties.components}
+`;
+    ascii += `  Transformation: ${thought.tensorProperties.transformation}
+`;
+    if (thought.tensorProperties.symmetries.length > 0) {
+      ascii += "  Symmetries:\n";
+      thought.tensorProperties.symmetries.forEach((sym, index) => {
+        ascii += `    ${index + 1}. ${sym}
+`;
+      });
+    }
+    ascii += "\n";
+  }
+  if (thought.physicalInterpretation) {
+    ascii += "Physical Interpretation:\n";
+    ascii += `  Quantity: ${thought.physicalInterpretation.quantity}
+`;
+    ascii += `  Units: ${thought.physicalInterpretation.units}
+`;
+    if (thought.physicalInterpretation.conservationLaws.length > 0) {
+      ascii += "  Conservation Laws:\n";
+      thought.physicalInterpretation.conservationLaws.forEach((law, index) => {
+        ascii += `    ${index + 1}. ${law}
+`;
+      });
+    }
+    ascii += "\n";
+  }
+  if (thought.assumptions && thought.assumptions.length > 0) {
+    ascii += "Assumptions:\n";
+    thought.assumptions.forEach((assumption, index) => {
+      ascii += `  ${index + 1}. ${assumption}
+`;
+    });
+    ascii += "\n";
+  }
+  if (thought.dependencies && thought.dependencies.length > 0) {
+    ascii += "Dependencies:\n";
+    thought.dependencies.forEach((dep, index) => {
+      ascii += `  ${index + 1}. ${dep}
+`;
+    });
+    ascii += "\n";
+  }
+  if (thought.revisionReason) {
+    ascii += `Revision Reason: ${thought.revisionReason}
+`;
+  }
+  return ascii;
+}
+var init_hybrid = __esm({
+  "src/export/visual/hybrid.ts"() {
+    init_esm_shims();
+    init_utils();
+  }
+});
+
+// src/export/visual/metareasoning.ts
+function exportMetaReasoningVisualization(thought, options) {
+  const { format, colorScheme = "default", includeLabels = true, includeMetrics = true } = options;
+  switch (format) {
+    case "mermaid":
+      return metaReasoningToMermaid(thought, colorScheme, includeLabels, includeMetrics);
+    case "dot":
+      return metaReasoningToDOT(thought, includeLabels, includeMetrics);
+    case "ascii":
+      return metaReasoningToASCII(thought);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function metaReasoningToMermaid(thought, colorScheme, includeLabels, includeMetrics) {
+  let mermaid = "graph TB\n";
+  const metaId = sanitizeId("meta_reasoning");
+  mermaid += `  ${metaId}(("Meta-Reasoning"))
+`;
+  const currentId = sanitizeId("current_strategy");
+  const currentLabel = includeLabels ? thought.currentStrategy.approach : "Current Strategy";
+  mermaid += `  ${currentId}[["${currentLabel}"]]
+`;
+  mermaid += `  ${metaId} ==> ${currentId}
+`;
+  const modeId = sanitizeId("current_mode");
+  mermaid += `  ${modeId}(["Mode: ${thought.currentStrategy.mode}"])
+`;
+  mermaid += `  ${currentId} --> ${modeId}
+`;
+  const evalId = sanitizeId("evaluation");
+  mermaid += `  ${evalId}{{"Effectiveness: ${(thought.strategyEvaluation.effectiveness * 100).toFixed(0)}%"}}
+`;
+  mermaid += `  ${currentId} --> ${evalId}
+`;
+  if (thought.strategyEvaluation.issues.length > 0) {
+    const issuesId = sanitizeId("issues");
+    mermaid += `  ${issuesId}>"Issues: ${thought.strategyEvaluation.issues.length}"]
+`;
+    mermaid += `  ${evalId} --> ${issuesId}
+`;
+  }
+  if (thought.strategyEvaluation.strengths.length > 0) {
+    const strengthsId = sanitizeId("strengths");
+    mermaid += `  ${strengthsId}>"Strengths: ${thought.strategyEvaluation.strengths.length}"]
+`;
+    mermaid += `  ${evalId} --> ${strengthsId}
+`;
+  }
+  if (thought.alternativeStrategies.length > 0) {
+    const altsId = sanitizeId("alternatives");
+    mermaid += `  ${altsId}(["Alternative Strategies"])
+`;
+    mermaid += `  ${metaId} --> ${altsId}
+`;
+    thought.alternativeStrategies.forEach((alt, index) => {
+      const altId = sanitizeId(`alt_${index}`);
+      const altLabel = includeLabels ? `${alt.mode}: ${(alt.recommendationScore * 100).toFixed(0)}%` : `Alt ${index + 1}`;
+      mermaid += `  ${altId}["${altLabel}"]
+`;
+      mermaid += `  ${altsId} --> ${altId}
+`;
+    });
+  }
+  const recId = sanitizeId("recommendation");
+  const recLabel = `${thought.recommendation.action}${thought.recommendation.targetMode ? ` \u2192 ${thought.recommendation.targetMode}` : ""}`;
+  mermaid += `  ${recId}[/"${recLabel}"/]
+`;
+  mermaid += `  ${metaId} ==> ${recId}
+`;
+  if (includeMetrics) {
+    const confId = sanitizeId("rec_confidence");
+    mermaid += `  ${confId}{{"Confidence: ${(thought.recommendation.confidence * 100).toFixed(0)}%"}}
+`;
+    mermaid += `  ${recId} --> ${confId}
+`;
+  }
+  if (includeMetrics) {
+    const qualityId = sanitizeId("quality");
+    const qualityLabel = `Quality: ${(thought.qualityMetrics.overallQuality * 100).toFixed(0)}%`;
+    mermaid += `  ${qualityId}{{"${qualityLabel}"}}
+`;
+    mermaid += `  ${metaId} -.-> ${qualityId}
+`;
+  }
+  const resourceId = sanitizeId("resources");
+  mermaid += `  ${resourceId}[("Complexity: ${thought.resourceAllocation.complexityLevel}")]
+`;
+  mermaid += `  ${metaId} -.-> ${resourceId}
+`;
+  const sessionId = sanitizeId("session");
+  mermaid += `  ${sessionId}>"Thoughts: ${thought.sessionContext.totalThoughts}"]
+`;
+  mermaid += `  ${metaId} -.-> ${sessionId}
+`;
+  if (colorScheme !== "monochrome") {
+    const colors = colorScheme === "pastel" ? { meta: "#f3e5f5", current: "#e3f2fd", rec: "#e8f5e9", alt: "#fff3e0" } : { meta: "#DDA0DD", current: "#87CEEB", rec: "#90EE90", alt: "#FFD700" };
+    mermaid += `
+  style ${metaId} fill:${colors.meta}
+`;
+    mermaid += `  style ${currentId} fill:${colors.current}
+`;
+    mermaid += `  style ${recId} fill:${colors.rec}
+`;
+    if (thought.alternativeStrategies.length > 0) {
+      mermaid += `  style ${sanitizeId("alternatives")} fill:${colors.alt}
+`;
+    }
+  }
+  return mermaid;
+}
+function metaReasoningToDOT(thought, includeLabels, includeMetrics) {
+  let dot = "digraph MetaReasoning {\n";
+  dot += "  rankdir=TB;\n";
+  dot += "  node [shape=box, style=rounded];\n\n";
+  dot += "  subgraph cluster_current {\n";
+  dot += '    label="Current Strategy";\n';
+  dot += "    style=filled;\n";
+  dot += "    fillcolor=lightblue;\n";
+  const currentId = sanitizeId("current_strategy");
+  const currentLabel = includeLabels ? thought.currentStrategy.approach.slice(0, 30).replace(/"/g, '\\"') : "Current Strategy";
+  dot += `    ${currentId} [label="${currentLabel}"];
+`;
+  const modeId = sanitizeId("current_mode");
+  dot += `    ${modeId} [label="${thought.currentStrategy.mode}", shape=ellipse];
+`;
+  dot += `    ${currentId} -> ${modeId};
+`;
+  if (includeMetrics) {
+    const evalId = sanitizeId("evaluation");
+    dot += `    ${evalId} [label="Eff: ${(thought.strategyEvaluation.effectiveness * 100).toFixed(0)}%", shape=diamond];
+`;
+    dot += `    ${currentId} -> ${evalId};
+`;
+  }
+  dot += "  }\n\n";
+  if (thought.alternativeStrategies.length > 0) {
+    dot += "  subgraph cluster_alternatives {\n";
+    dot += '    label="Alternatives";\n';
+    dot += "    style=filled;\n";
+    dot += "    fillcolor=lightyellow;\n";
+    thought.alternativeStrategies.forEach((alt, index) => {
+      const altId = sanitizeId(`alt_${index}`);
+      const altLabel = `${alt.mode}\\n${(alt.recommendationScore * 100).toFixed(0)}%`;
+      dot += `    ${altId} [label="${altLabel}"];
+`;
+    });
+    dot += "  }\n\n";
+  }
+  const recId = sanitizeId("recommendation");
+  const recLabel = `${thought.recommendation.action}${thought.recommendation.targetMode ? `\\n\u2192 ${thought.recommendation.targetMode}` : ""}`;
+  dot += `  ${recId} [label="${recLabel}", shape=hexagon, style="filled", fillcolor=lightgreen];
+`;
+  if (includeMetrics) {
+    const qualityId = sanitizeId("quality");
+    const qualityLabel = `Quality: ${(thought.qualityMetrics.overallQuality * 100).toFixed(0)}%`;
+    dot += `  ${qualityId} [label="${qualityLabel}", shape=diamond];
+`;
+  }
+  dot += `  ${currentId} -> ${recId} [style=bold, penwidth=2];
+`;
+  thought.alternativeStrategies.forEach((_, index) => {
+    const altId = sanitizeId(`alt_${index}`);
+    dot += `  ${altId} -> ${recId} [style=dashed];
+`;
+  });
+  dot += "}\n";
+  return dot;
+}
+function metaReasoningToASCII(thought) {
+  let ascii = "Meta-Reasoning Analysis:\n";
+  ascii += "========================\n\n";
+  ascii += "CURRENT STRATEGY\n";
+  ascii += "----------------\n";
+  ascii += `Mode: ${thought.currentStrategy.mode}
+`;
+  ascii += `Approach: ${thought.currentStrategy.approach}
+`;
+  ascii += `Thoughts Spent: ${thought.currentStrategy.thoughtsSpent}
+`;
+  if (thought.currentStrategy.progressIndicators.length > 0) {
+    ascii += "Progress Indicators:\n";
+    thought.currentStrategy.progressIndicators.forEach((ind, index) => {
+      ascii += `  ${index + 1}. ${ind}
+`;
+    });
+  }
+  ascii += "\n";
+  ascii += "STRATEGY EVALUATION\n";
+  ascii += "-------------------\n";
+  ascii += `Effectiveness: ${(thought.strategyEvaluation.effectiveness * 100).toFixed(1)}%
+`;
+  ascii += `Efficiency: ${(thought.strategyEvaluation.efficiency * 100).toFixed(1)}%
+`;
+  ascii += `Confidence: ${(thought.strategyEvaluation.confidence * 100).toFixed(1)}%
+`;
+  ascii += `Progress Rate: ${thought.strategyEvaluation.progressRate.toFixed(2)} insights/thought
+`;
+  ascii += `Quality Score: ${(thought.strategyEvaluation.qualityScore * 100).toFixed(1)}%
+`;
+  if (thought.strategyEvaluation.strengths.length > 0) {
+    ascii += "Strengths:\n";
+    thought.strategyEvaluation.strengths.forEach((s, index) => {
+      ascii += `  + ${index + 1}. ${s}
+`;
+    });
+  }
+  if (thought.strategyEvaluation.issues.length > 0) {
+    ascii += "Issues:\n";
+    thought.strategyEvaluation.issues.forEach((issue, index) => {
+      ascii += `  - ${index + 1}. ${issue}
+`;
+    });
+  }
+  ascii += "\n";
+  if (thought.alternativeStrategies.length > 0) {
+    ascii += "ALTERNATIVE STRATEGIES\n";
+    ascii += "----------------------\n";
+    thought.alternativeStrategies.forEach((alt, index) => {
+      ascii += `[${index + 1}] ${alt.mode}
+`;
+      ascii += `    Reasoning: ${alt.reasoning}
+`;
+      ascii += `    Expected Benefit: ${alt.expectedBenefit}
+`;
+      ascii += `    Switching Cost: ${(alt.switchingCost * 100).toFixed(0)}%
+`;
+      ascii += `    Recommendation Score: ${(alt.recommendationScore * 100).toFixed(0)}%
+`;
+    });
+    ascii += "\n";
+  }
+  ascii += "RECOMMENDATION\n";
+  ascii += "--------------\n";
+  ascii += `Action: ${thought.recommendation.action}
+`;
+  if (thought.recommendation.targetMode) {
+    ascii += `Target Mode: ${thought.recommendation.targetMode}
+`;
+  }
+  ascii += `Justification: ${thought.recommendation.justification}
+`;
+  ascii += `Confidence: ${(thought.recommendation.confidence * 100).toFixed(1)}%
+`;
+  ascii += `Expected Improvement: ${thought.recommendation.expectedImprovement}
+`;
+  ascii += "\n";
+  ascii += "RESOURCE ALLOCATION\n";
+  ascii += "-------------------\n";
+  ascii += `Time Spent: ${thought.resourceAllocation.timeSpent}ms
+`;
+  ascii += `Thoughts Remaining: ${thought.resourceAllocation.thoughtsRemaining}
+`;
+  ascii += `Complexity: ${thought.resourceAllocation.complexityLevel}
+`;
+  ascii += `Urgency: ${thought.resourceAllocation.urgency}
+`;
+  ascii += `Recommendation: ${thought.resourceAllocation.recommendation}
+`;
+  ascii += "\n";
+  ascii += "QUALITY METRICS\n";
+  ascii += "---------------\n";
+  ascii += `Logical Consistency: ${(thought.qualityMetrics.logicalConsistency * 100).toFixed(1)}%
+`;
+  ascii += `Evidence Quality: ${(thought.qualityMetrics.evidenceQuality * 100).toFixed(1)}%
+`;
+  ascii += `Completeness: ${(thought.qualityMetrics.completeness * 100).toFixed(1)}%
+`;
+  ascii += `Originality: ${(thought.qualityMetrics.originality * 100).toFixed(1)}%
+`;
+  ascii += `Clarity: ${(thought.qualityMetrics.clarity * 100).toFixed(1)}%
+`;
+  ascii += `Overall Quality: ${(thought.qualityMetrics.overallQuality * 100).toFixed(1)}%
+`;
+  ascii += "\n";
+  ascii += "SESSION CONTEXT\n";
+  ascii += "---------------\n";
+  ascii += `Session ID: ${thought.sessionContext.sessionId}
+`;
+  ascii += `Total Thoughts: ${thought.sessionContext.totalThoughts}
+`;
+  ascii += `Mode Switches: ${thought.sessionContext.modeSwitches}
+`;
+  ascii += `Problem Type: ${thought.sessionContext.problemType}
+`;
+  ascii += `Modes Used: ${thought.sessionContext.modesUsed.join(", ")}
+`;
+  if (thought.sessionContext.historicalEffectiveness !== void 0) {
+    ascii += `Historical Effectiveness: ${(thought.sessionContext.historicalEffectiveness * 100).toFixed(1)}%
+`;
+  }
+  return ascii;
+}
+var init_metareasoning = __esm({
+  "src/export/visual/metareasoning.ts"() {
+    init_esm_shims();
+    init_utils();
+  }
+});
+
+// src/export/visual/index.ts
+var VisualExporter;
+var init_visual = __esm({
+  "src/export/visual/index.ts"() {
+    init_esm_shims();
+    init_causal();
+    init_temporal();
+    init_game_theory();
+    init_bayesian();
+    init_sequential();
+    init_shannon();
+    init_abductive();
+    init_counterfactual();
+    init_analogical();
+    init_evidential();
+    init_first_principles();
+    init_systems_thinking();
+    init_scientific_method();
+    init_optimization();
+    init_formal_logic();
+    init_mathematics();
+    init_physics();
+    init_hybrid();
+    init_metareasoning();
+    VisualExporter = class {
+      exportCausalGraph(thought, options) {
+        return exportCausalGraph(thought, options);
+      }
+      exportTemporalTimeline(thought, options) {
+        return exportTemporalTimeline(thought, options);
+      }
+      exportGameTree(thought, options) {
+        return exportGameTree(thought, options);
+      }
+      exportBayesianNetwork(thought, options) {
+        return exportBayesianNetwork(thought, options);
+      }
+      exportSequentialDependencyGraph(thought, options) {
+        return exportSequentialDependencyGraph(thought, options);
+      }
+      exportShannonStageFlow(thought, options) {
+        return exportShannonStageFlow(thought, options);
+      }
+      exportAbductiveHypotheses(thought, options) {
+        return exportAbductiveHypotheses(thought, options);
+      }
+      exportCounterfactualScenarios(thought, options) {
+        return exportCounterfactualScenarios(thought, options);
+      }
+      exportAnalogicalMapping(thought, options) {
+        return exportAnalogicalMapping(thought, options);
+      }
+      exportEvidentialBeliefs(thought, options) {
+        return exportEvidentialBeliefs(thought, options);
+      }
+      exportFirstPrinciplesDerivation(thought, options) {
+        return exportFirstPrinciplesDerivation(thought, options);
+      }
+      exportSystemsThinkingCausalLoops(thought, options) {
+        return exportSystemsThinkingCausalLoops(thought, options);
+      }
+      exportScientificMethodExperiment(thought, options) {
+        return exportScientificMethodExperiment(thought, options);
+      }
+      exportOptimizationSolution(thought, options) {
+        return exportOptimizationSolution(thought, options);
+      }
+      exportFormalLogicProof(thought, options) {
+        return exportFormalLogicProof(thought, options);
+      }
+      // Sprint 2: New visual export wrapper methods
+      exportMathematicsDerivation(thought, options) {
+        return exportMathematicsDerivation(thought, options);
+      }
+      exportPhysicsVisualization(thought, options) {
+        return exportPhysicsVisualization(thought, options);
+      }
+      exportHybridOrchestration(thought, options) {
+        return exportHybridOrchestration(thought, options);
+      }
+      exportMetaReasoningVisualization(thought, options) {
+        return exportMetaReasoningVisualization(thought, options);
+      }
+    };
+  }
+});
+
+// src/services/ExportService.ts
+var ExportService;
+var init_ExportService = __esm({
+  "src/services/ExportService.ts"() {
+    init_esm_shims();
+    init_types();
+    init_visual();
+    init_sanitization();
+    init_logger();
+    ExportService = class {
+      visualExporter;
+      logger;
+      constructor(logger2) {
+        this.visualExporter = new VisualExporter();
+        this.logger = logger2 || createLogger({ minLevel: 1 /* INFO */, enableConsole: true });
       }
       /**
        * Export a session to the specified format
@@ -5103,6 +6510,118 @@ var init_ExportService = __esm({
             colorScheme: "default"
           });
         }
+        if (lastThought.mode === "sequential" /* SEQUENTIAL */ && "buildUpon" in lastThought) {
+          return this.visualExporter.exportSequentialDependencyGraph(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "shannon" /* SHANNON */ && "stage" in lastThought) {
+          return this.visualExporter.exportShannonStageFlow(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "abductive" /* ABDUCTIVE */ && "hypotheses" in lastThought) {
+          return this.visualExporter.exportAbductiveHypotheses(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "counterfactual" /* COUNTERFACTUAL */ && "scenarios" in lastThought) {
+          return this.visualExporter.exportCounterfactualScenarios(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "analogical" /* ANALOGICAL */ && "sourceAnalogy" in lastThought) {
+          return this.visualExporter.exportAnalogicalMapping(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "evidential" /* EVIDENTIAL */ && "frameOfDiscernment" in lastThought) {
+          return this.visualExporter.exportEvidentialBeliefs(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "systemsthinking" /* SYSTEMSTHINKING */ && "systemComponents" in lastThought) {
+          return this.visualExporter.exportSystemsThinkingCausalLoops(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "scientificmethod" /* SCIENTIFICMETHOD */ && "hypothesis" in lastThought) {
+          return this.visualExporter.exportScientificMethodExperiment(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "optimization" /* OPTIMIZATION */ && "objectiveFunction" in lastThought) {
+          return this.visualExporter.exportOptimizationSolution(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "formallogic" /* FORMALLOGIC */ && "premises" in lastThought) {
+          return this.visualExporter.exportFormalLogicProof(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "mathematics" /* MATHEMATICS */ && "proofStrategy" in lastThought) {
+          return this.visualExporter.exportMathematicsDerivation(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "physics" /* PHYSICS */ && "tensorProperties" in lastThought) {
+          return this.visualExporter.exportPhysicsVisualization(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "hybrid" /* HYBRID */ && "primaryMode" in lastThought) {
+          return this.visualExporter.exportHybridOrchestration(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
+        if (lastThought.mode === "metareasoning" /* METAREASONING */ && "currentStrategy" in lastThought) {
+          return this.visualExporter.exportMetaReasoningVisualization(lastThought, {
+            format,
+            colorScheme: "default",
+            includeLabels: true,
+            includeMetrics: true
+          });
+        }
         const thoughts = session.thoughts.map(
           (t, i) => `Thought ${i + 1} (${t.mode}):
 ${t.content}
@@ -5162,6 +6681,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 +6912,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 +7097,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 +7905,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 +8444,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 +8491,7 @@ var modeToToolMap = {
   // Analytical modes
   analogical: "deepthinking_analytical",
   firstprinciples: "deepthinking_analytical",
+  metareasoning: "deepthinking_analytical",
   // Scientific modes
   scientificmethod: "deepthinking_scientific",
   systemsthinking: "deepthinking_scientific",