deepthinking-mcp 6.0.0 → 6.1.1

package/dist/index.js

@@ -1243,13 +1243,10 @@ var init_sanitization = __esm({
   }
 });
 
-// src/utils/logger.ts
-function createLogger(config) {
-  return new Logger(config);
-}
-var LogLevel, DEFAULT_CONFIG, Logger;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
+// src/utils/logger-types.ts
+var LogLevel;
+var init_logger_types = __esm({
+  "src/utils/logger-types.ts"() {
     init_esm_shims();
     LogLevel = /* @__PURE__ */ ((LogLevel2) => {
       LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
@@ -1259,6 +1256,18 @@ var init_logger = __esm({
       LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
       return LogLevel2;
     })(LogLevel || {});
+  }
+});
+
+// src/utils/logger.ts
+function createLogger(config) {
+  return new Logger(config);
+}
+var DEFAULT_CONFIG, Logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    init_esm_shims();
+    init_logger_types();
     DEFAULT_CONFIG = {
       minLevel: 1 /* INFO */,
       enableConsole: true,
@@ -5198,153 +5207,1268 @@ 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_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
-       *
-       * Main export method that routes to format-specific exporters.
-       * Handles both standard formats (JSON, Markdown, etc.) and visual
-       * formats (Mermaid, DOT, ASCII).
-       *
-       * @param session - The session to export
-       * @param format - The desired export format
-       * @returns Formatted string in the requested format
-       * @throws {Error} If session has no thoughts for visual exports
-       *
-       * @example
-       * ```typescript
-       * const service = new ExportService();
-       * const exported = service.exportSession(session, 'markdown');
-       * ```
-       */
-      exportSession(session, format) {
-        const startTime = Date.now();
-        this.logger.debug("Export started", { sessionId: session.id, format, thoughtCount: session.thoughts.length });
-        if (format === "mermaid" || format === "dot" || format === "ascii") {
-          const result2 = this.exportVisual(session, format);
-          this.logger.debug("Export completed", {
-            sessionId: session.id,
-            format,
-            duration: Date.now() - startTime,
-            outputSize: result2.length
-          });
-          return result2;
-        }
-        let result;
-        switch (format) {
-          case "json":
-            result = this.exportToJSON(session);
-            break;
-          case "markdown":
-            result = this.exportToMarkdown(session);
-            break;
-          case "latex":
-            result = this.exportToLatex(session);
-            break;
-          case "html":
-            result = this.exportToHTML(session);
-            break;
-          case "jupyter":
-            result = this.exportToJupyter(session);
-            break;
-          default:
-            result = this.exportToJSON(session);
-        }
-        this.logger.debug("Export completed", {
-          sessionId: session.id,
-          format,
-          duration: Date.now() - startTime,
-          outputSize: result.length
-        });
-        return result;
-      }
-      /**
-       * Export session to visual format (Mermaid, DOT, ASCII)
+// 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
+       *
+       * Main export method that routes to format-specific exporters.
+       * Handles both standard formats (JSON, Markdown, etc.) and visual
+       * formats (Mermaid, DOT, ASCII).
+       *
+       * @param session - The session to export
+       * @param format - The desired export format
+       * @returns Formatted string in the requested format
+       * @throws {Error} If session has no thoughts for visual exports
+       *
+       * @example
+       * ```typescript
+       * const service = new ExportService();
+       * const exported = service.exportSession(session, 'markdown');
+       * ```
+       */
+      exportSession(session, format) {
+        const startTime = Date.now();
+        this.logger.debug("Export started", { sessionId: session.id, format, thoughtCount: session.thoughts.length });
+        if (format === "mermaid" || format === "dot" || format === "ascii") {
+          const result2 = this.exportVisual(session, format);
+          this.logger.debug("Export completed", {
+            sessionId: session.id,
+            format,
+            duration: Date.now() - startTime,
+            outputSize: result2.length
+          });
+          return result2;
+        }
+        let result;
+        switch (format) {
+          case "json":
+            result = this.exportToJSON(session);
+            break;
+          case "markdown":
+            result = this.exportToMarkdown(session);
+            break;
+          case "latex":
+            result = this.exportToLatex(session);
+            break;
+          case "html":
+            result = this.exportToHTML(session);
+            break;
+          case "jupyter":
+            result = this.exportToJupyter(session);
+            break;
+          default:
+            result = this.exportToJSON(session);
+        }
+        this.logger.debug("Export completed", {
+          sessionId: session.id,
+          format,
+          duration: Date.now() - startTime,
+          outputSize: result.length
+        });
+        return result;
+      }
+      /**
+       * Export session to visual format (Mermaid, DOT, ASCII)
        *
        * Uses VisualExporter to generate visual representations
        * based on the session's thinking mode and thought structure.
@@ -5395,6 +6519,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}