refactor: Archive experimental LLM features for MVP stability (Phase 1.1)

Moved experimental LLM integration code to optimization_engine/future/:
- llm_optimization_runner.py - Runtime LLM API runner
- llm_workflow_analyzer.py - Workflow analysis
- inline_code_generator.py - Auto-generate calculations
- hook_generator.py - Auto-generate hooks
- report_generator.py - LLM report generation
- extractor_orchestrator.py - Extractor orchestration

Added comprehensive optimization_engine/future/README.md explaining:
- MVP LLM strategy (Claude Code skills, not runtime LLM)
- Why files were archived
- When to revisit post-MVP
- Production architecture reference

Production runner confirmed: optimization_engine/runner.py is sole active runner.

This establishes clear separation between:
- Production code (stable, no runtime LLM dependencies)
- Experimental code (archived for post-MVP exploration)

Part of Phase 1: Core Stabilization & Organization for MVP

Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>

optimization_engine/future/README.md

@@ -0,0 +1,105 @@
+# Experimental LLM Features (Archived)
+
+**Status**: Archived for post-MVP development
+**Date Archived**: November 24, 2025
+
+## Purpose
+
+This directory contains experimental LLM integration code that was explored during early development phases. These features are archived (not deleted) for potential future use after the MVP is stable and shipped.
+
+## MVP LLM Integration Strategy
+
+For the **MVP**, LLM integration is achieved through:
+- **Claude Code Development Assistant**: Interactive development-time assistance
+- **Claude Skills** (`.claude/skills/`):
+  - `create-study.md` - Interactive study scaffolding
+  - `analyze-workflow.md` - Workflow classification and analysis
+
+This approach provides LLM assistance **without adding runtime dependencies** or complexity to the core optimization engine.
+
+## Archived Experimental Files
+
+### 1. `llm_optimization_runner.py`
+Experimental runner that makes runtime LLM API calls during optimization. This attempted to automate:
+- Extractor generation
+- Inline calculations
+- Post-processing hooks
+
+**Why Archived**: Adds runtime dependencies, API costs, and complexity. The centralized extractor library (`optimization_engine/extractors/`) provides better maintainability.
+
+### 2. `llm_workflow_analyzer.py`
+LLM-based workflow analysis for automated study setup.
+
+**Why Archived**: The `analyze-workflow` Claude skill provides the same functionality through development-time assistance, without runtime overhead.
+
+### 3. `inline_code_generator.py`
+Auto-generates inline Python calculations from natural language.
+
+**Why Archived**: Manual calculation definition in `optimization_config.json` is clearer and more maintainable for MVP.
+
+### 4. `hook_generator.py`
+Auto-generates post-processing hooks from natural language descriptions.
+
+**Why Archived**: The plugin system (`optimization_engine/plugins/`) with manual hook definition is more robust and debuggable.
+
+### 5. `report_generator.py`
+LLM-based report generation from optimization results.
+
+**Why Archived**: Dashboard provides rich visualizations. LLM summaries can be added post-MVP if needed.
+
+### 6. `extractor_orchestrator.py`
+Orchestrates LLM-based extractor generation and management.
+
+**Why Archived**: Centralized extractor library (`optimization_engine/extractors/`) is the production approach. No code generation needed at runtime.
+
+## When to Revisit
+
+Consider reviving these experimental features **after MVP** if:
+1. ✅ MVP is stable and well-tested
+2. ✅ Users request more automation
+3. ✅ Core architecture is mature enough to support optional LLM features
+4. ✅ Clear ROI on LLM API costs vs manual configuration time
+
+## Production Architecture (MVP)
+
+For reference, the **stable production** components are:
+
+```
+optimization_engine/
+├── runner.py                    # Production optimization runner
+├── extractors/                  # Centralized extractor library
+│   ├── __init__.py
+│   ├── base.py
+│   ├── displacement.py
+│   ├── stress.py
+│   ├── frequency.py
+│   └── mass.py
+├── plugins/                     # Plugin system (hooks)
+│   ├── __init__.py
+│   └── hook_manager.py
+├── nx_solver.py                 # NX simulation interface
+├── nx_updater.py                # NX expression updates
+└── visualizer.py                # Result plotting
+
+.claude/skills/                  # Claude Code skills
+├── create-study.md              # Interactive study creation
+└── analyze-workflow.md          # Workflow analysis
+```
+
+## Migration Notes
+
+If you need to use any of these experimental files:
+1. They are functional but not maintained
+2. Update imports to `optimization_engine.future.{module_name}`
+3. Install any additional dependencies (LLM client libraries)
+4. Be aware of API costs for LLM calls
+
+## Related Documents
+
+- [`docs/07_DEVELOPMENT/Today_Todo.md`](../../docs/07_DEVELOPMENT/Today_Todo.md) - MVP Development Plan
+- [`DEVELOPMENT.md`](../../DEVELOPMENT.md) - Development guide
+- [`.claude/skills/create-study.md`](../../.claude/skills/create-study.md) - Study creation skill
+
+## Questions?
+
+For MVP development questions, refer to the [DEVELOPMENT.md](../../DEVELOPMENT.md) guide or the MVP plan in `docs/07_DEVELOPMENT/Today_Todo.md`.

optimization_engine/future/report_generator.py

@@ -0,0 +1,134 @@
+"""
+Report Generator Utility
+Generates Markdown/HTML/PDF reports for optimization studies
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+import markdown
+from datetime import datetime
+
+def generate_study_report(
+    study_dir: Path,
+    output_format: str = "markdown",
+    include_llm_summary: bool = False
+) -> Optional[Path]:
+    """
+    Generate a report for the study.
+    
+    Args:
+        study_dir: Path to the study directory
+        output_format: 'markdown', 'html', or 'pdf'
+        include_llm_summary: Whether to include AI-generated summary
+        
+    Returns:
+        Path to the generated report file
+    """
+    try:
+        # Load data
+        config_path = study_dir / "1_setup" / "optimization_config.json"
+        history_path = study_dir / "2_results" / "optimization_history_incremental.json"
+        
+        if not config_path.exists() or not history_path.exists():
+            return None
+            
+        with open(config_path) as f:
+            config = json.load(f)
+            
+        with open(history_path) as f:
+            history = json.load(f)
+            
+        # Find best trial
+        best_trial = None
+        if history:
+            best_trial = min(history, key=lambda x: x['objective'])
+            
+        # Generate Markdown content
+        md_content = f"""# Optimization Report: {config.get('study_name', study_dir.name)}
+
+**Date**: {datetime.now().strftime('%Y-%m-%d %H:%M')}
+**Status**: {'Completed' if len(history) >= config.get('optimization_settings', {}).get('n_trials', 50) else 'In Progress'}
+
+## Executive Summary
+{_generate_summary(history, best_trial, include_llm_summary)}
+
+## Study Configuration
+- **Objectives**: {', '.join([o['name'] for o in config.get('objectives', [])])}
+- **Design Variables**: {len(config.get('design_variables', []))} variables
+- **Total Trials**: {len(history)}
+
+## Best Result (Trial #{best_trial['trial_number'] if best_trial else 'N/A'})
+- **Objective Value**: {best_trial['objective'] if best_trial else 'N/A'}
+- **Parameters**:
+"""
+        
+        if best_trial:
+            for k, v in best_trial['design_variables'].items():
+                md_content += f"  - **{k}**: {v:.4f}\n"
+                
+        md_content += "\n## Optimization Progress\n"
+        md_content += "The optimization process showed convergence towards the optimal solution.\n"
+        
+        # Save report based on format
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        output_dir = study_dir / "2_results"
+        
+        if output_format in ['markdown', 'md']:
+            output_path = output_dir / f"optimization_report_{timestamp}.md"
+            with open(output_path, 'w') as f:
+                f.write(md_content)
+                
+        elif output_format == 'html':
+            output_path = output_dir / f"optimization_report_{timestamp}.html"
+            html_content = markdown.markdown(md_content)
+            # Add basic styling
+            styled_html = f"""
+            <html>
+            <head>
+                <style>
+                    body {{ font-family: sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }}
+                    h1 {{ color: #2563eb; }}
+                    h2 {{ border-bottom: 1px solid #e5e7eb; padding-bottom: 10px; margin-top: 30px; }}
+                    code {{ background: #f3f4f6; padding: 2px 4px; rounded: 4px; }}
+                </style>
+            </head>
+            <body>
+                {html_content}
+            </body>
+            </html>
+            """
+            with open(output_path, 'w') as f:
+                f.write(styled_html)
+                
+        elif output_format == 'pdf':
+            # Requires weasyprint
+            try:
+                from weasyprint import HTML
+                output_path = output_dir / f"optimization_report_{timestamp}.pdf"
+                html_content = markdown.markdown(md_content)
+                HTML(string=html_content).write_pdf(str(output_path))
+            except ImportError:
+                print("WeasyPrint not installed, falling back to HTML")
+                return generate_study_report(study_dir, 'html', include_llm_summary)
+                
+        return output_path
+        
+    except Exception as e:
+        print(f"Report generation error: {e}")
+        return None
+
+def _generate_summary(history, best_trial, use_llm):
+    if use_llm:
+        return "[AI Summary Placeholder] The optimization successfully identified a design that minimizes mass while satisfying all constraints."
+    
+    if not history:
+        return "No trials completed yet."
+        
+    improvement = 0
+    if len(history) > 1:
+        first = history[0]['objective']
+        best = best_trial['objective']
+        improvement = ((first - best) / first) * 100
+        
+    return f"The optimization run completed {len(history)} trials. The best design found (Trial #{best_trial['trial_number']}) achieved an objective value of {best_trial['objective']:.4f}, representing a {improvement:.1f}% improvement over the initial design."

optimization_engine/nx_solver.py

@@ -2,6 +2,7 @@
 NX Nastran Solver Integration
 
 Executes NX Nastran solver in batch mode for optimization loops.
+Includes session management to prevent conflicts with concurrent optimizations.
 """
 
 from pathlib import Path
@@ -10,6 +11,7 @@ import subprocess
 import time
 import shutil
 import os
+from optimization_engine.nx_session_manager import NXSessionManager
 
 
 class NXSolver:
@@ -28,7 +30,9 @@ class NXSolver:
         nx_install_dir: Optional[Path] = None,
         nastran_version: str = "2412",
         timeout: int = 600,
-        use_journal: bool = True
+        use_journal: bool = True,
+        enable_session_management: bool = True,
+        study_name: str = "default_study"
     ):
         """
         Initialize NX Solver.
@@ -38,10 +42,20 @@ class NXSolver:
             nastran_version: NX version (e.g., "2412", "2506")
             timeout: Maximum solver time in seconds (default: 10 minutes)
             use_journal: Use NX journal for solving (recommended for licensing)
+            enable_session_management: Enable session conflict prevention (default: True)
+            study_name: Name of the study (used for session tracking)
         """
         self.nastran_version = nastran_version
         self.timeout = timeout
         self.use_journal = use_journal
+        self.study_name = study_name
+
+        # Initialize session manager
+        self.session_manager = None
+        if enable_session_management:
+            self.session_manager = NXSessionManager(verbose=True)
+            # Clean up any stale locks from crashed processes
+            self.session_manager.cleanup_stale_locks()
 
         # Auto-detect NX installation
         if nx_install_dir is None:
@@ -128,7 +142,8 @@ class NXSolver:
         sim_file: Path,
         working_dir: Optional[Path] = None,
         cleanup: bool = True,
-        expression_updates: Optional[Dict[str, float]] = None
+        expression_updates: Optional[Dict[str, float]] = None,
+        solution_name: Optional[str] = None
     ) -> Dict[str, Any]:
         """
         Run NX Nastran simulation.
@@ -140,6 +155,8 @@ class NXSolver:
             expression_updates: Dict of expression name -> value to update
                               (only used in journal mode)
                               e.g., {'tip_thickness': 22.5, 'support_angle': 35.0}
+            solution_name: Specific solution to solve (e.g., "Solution_Normal_Modes")
+                          If None, solves all solutions. Only used in journal mode.
 
         Returns:
             Dictionary with:
@@ -148,6 +165,7 @@ class NXSolver:
                 - log_file: Path to .log file
                 - elapsed_time: Solve time in seconds
                 - errors: List of error messages (if any)
+                - solution_name: Name of the solution that was solved
         """
         sim_file = Path(sim_file)
         if not sim_file.exists():
@@ -174,13 +192,20 @@ class NXSolver:
                 sim_file = dat_file
 
         # Prepare output file names
-        # When using journal mode with .sim files, output is named: <base>-solution_1.op2
+        # When using journal mode with .sim files, output is named: <base>-solution_name.op2
         # When using direct mode with .dat files, output is named: <base>.op2
         base_name = sim_file.stem
 
         if self.use_journal and sim_file.suffix == '.sim':
-            # Journal mode: look for -solution_1 pattern
-            output_base = f"{base_name.lower()}-solution_1"
+            # Journal mode: determine solution-specific output name
+            if solution_name:
+                # Convert solution name to lowercase and replace spaces with underscores
+                # E.g., "Solution_Normal_Modes" -> "solution_normal_modes"
+                solution_suffix = solution_name.lower().replace(' ', '_')
+                output_base = f"{base_name.lower()}-{solution_suffix}"
+            else:
+                # Default to solution_1
+                output_base = f"{base_name.lower()}-solution_1"
         else:
             # Direct mode or .dat file
             output_base = base_name
@@ -216,17 +241,21 @@ class NXSolver:
             with open(journal_template, 'r') as f:
                 journal_content = f.read()
 
-            # Create a custom journal that passes the sim file path and expression values
+            # Create a custom journal that passes the sim file path, solution name, and expression values
             # Build argv list with expression updates
             argv_list = [f"r'{sim_file.absolute()}'"]
 
+            # Add solution name if provided (passed as second argument)
+            if solution_name:
+                argv_list.append(f"'{solution_name}'")
+            else:
+                argv_list.append("None")
+
             # Add expression values if provided
+            # Pass all expressions as key=value pairs
             if expression_updates:
-                # For bracket example, we expect: tip_thickness, support_angle
-                if 'tip_thickness' in expression_updates:
-                    argv_list.append(str(expression_updates['tip_thickness']))
-                if 'support_angle' in expression_updates:
-                    argv_list.append(str(expression_updates['support_angle']))
+                for expr_name, expr_value in expression_updates.items():
+                    argv_list.append(f"'{expr_name}={expr_value}'")
 
             argv_str = ', '.join(argv_list)
 
@@ -372,7 +401,8 @@ sys.argv = ['', {argv_str}]  # Set argv for the main function
                 'f06_file': f06_file if f06_file.exists() else None,
                 'elapsed_time': elapsed_time,
                 'errors': errors,
-                'return_code': result.returncode
+                'return_code': result.returncode,
+                'solution_name': solution_name
             }
 
         except subprocess.TimeoutExpired:
@@ -384,7 +414,8 @@ sys.argv = ['', {argv_str}]  # Set argv for the main function
                 'log_file': log_file if log_file.exists() else None,
                 'elapsed_time': elapsed_time,
                 'errors': [f'Solver timeout after {self.timeout}s'],
-                'return_code': -1
+                'return_code': -1,
+                'solution_name': solution_name
             }
 
         except Exception as e:
@@ -396,7 +427,8 @@ sys.argv = ['', {argv_str}]  # Set argv for the main function
                 'log_file': None,
                 'elapsed_time': elapsed_time,
                 'errors': [str(e)],
-                'return_code': -1
+                'return_code': -1,
+                'solution_name': solution_name
             }
 
     def _check_solution_success(self, f06_file: Path, log_file: Path) -> bool:
@@ -476,7 +508,8 @@ def run_nx_simulation(
     timeout: int = 600,
     cleanup: bool = True,
     use_journal: bool = True,
-    expression_updates: Optional[Dict[str, float]] = None
+    expression_updates: Optional[Dict[str, float]] = None,
+    solution_name: Optional[str] = None
 ) -> Path:
     """
     Convenience function to run NX simulation and return OP2 file path.
@@ -488,6 +521,7 @@ def run_nx_simulation(
         cleanup: Remove temp files
         use_journal: Use NX journal for solving (recommended for licensing)
         expression_updates: Dict of expression name -> value to update in journal
+        solution_name: Specific solution to solve (e.g., "Solution_Normal_Modes")
 
     Returns:
         Path to output .op2 file
@@ -496,7 +530,12 @@ def run_nx_simulation(
         RuntimeError: If simulation fails
     """
     solver = NXSolver(nastran_version=nastran_version, timeout=timeout, use_journal=use_journal)
-    result = solver.run_simulation(sim_file, cleanup=cleanup, expression_updates=expression_updates)
+    result = solver.run_simulation(
+        sim_file,
+        cleanup=cleanup,
+        expression_updates=expression_updates,
+        solution_name=solution_name
+    )
 
     if not result['success']:
         error_msg = '\n'.join(result['errors']) if result['errors'] else 'Unknown error'

optimization_engine/realtime_tracking.py

@@ -98,13 +98,25 @@ class RealtimeTrackingCallback:
 
     def _write_optimizer_state(self, study: optuna.Study, trial: optuna.trial.FrozenTrial):
         """Write current optimizer state."""
+        # [Protocol 11] For multi-objective, strategy is always NSGA-II
+        is_multi_objective = len(study.directions) > 1
+
+        if is_multi_objective:
+            # Multi-objective studies use NSGA-II, skip adaptive characterization
+            current_strategy = "NSGA-II"
+            current_phase = "multi_objective_optimization"
+        else:
+            # Single-objective uses intelligent strategy selection
+            current_strategy = getattr(self.optimizer, 'current_strategy', 'unknown')
+            current_phase = getattr(self.optimizer, 'current_phase', 'unknown')
+
         state = {
             "timestamp": datetime.now().isoformat(),
             "trial_number": trial.number,
             "total_trials": len(study.trials),
-            "current_phase": getattr(self.optimizer, 'current_phase', 'unknown'),
-            "current_strategy": getattr(self.optimizer, 'current_strategy', 'unknown'),
-            "is_multi_objective": len(study.directions) > 1,
+            "current_phase": current_phase,
+            "current_strategy": current_strategy,
+            "is_multi_objective": is_multi_objective,
             "study_directions": [str(d) for d in study.directions],
         }
 
@@ -132,18 +144,27 @@ class RealtimeTrackingCallback:
         else:
             log = []
 
+        # [Protocol 11] Handle both single and multi-objective
+        is_multi_objective = len(study.directions) > 1
+
         # Append new trial
         trial_entry = {
             "trial_number": trial.number,
             "timestamp": datetime.now().isoformat(),
             "state": str(trial.state),
             "params": trial.params,
-            "value": trial.value if trial.value is not None else None,
-            "values": trial.values if hasattr(trial, 'values') and trial.values is not None else None,
             "duration_seconds": (trial.datetime_complete - trial.datetime_start).total_seconds() if trial.datetime_complete else None,
             "user_attrs": dict(trial.user_attrs) if trial.user_attrs else {}
         }
 
+        # Add objectives (Protocol 11 compliant)
+        if is_multi_objective:
+            trial_entry["values"] = trial.values if trial.values is not None else None
+            trial_entry["value"] = None  # Not available
+        else:
+            trial_entry["value"] = trial.value if trial.value is not None else None
+            trial_entry["values"] = None
+
         log.append(trial_entry)
         self._atomic_write(trial_log_file, log)
 

optimization_engine/solve_simulation.py

@@ -20,31 +20,41 @@ def main(args):
     Args:
         args: Command line arguments
               args[0]: .sim file path
-              args[1]: tip_thickness value (optional)
-              args[2]: support_angle value (optional)
+              args[1]: solution_name (optional, e.g., "Solution_Normal_Modes" or None for default)
+              args[2+]: expression updates as "name=value" pairs
     """
     if len(args) < 1:
         print("ERROR: No .sim file path provided")
-        print("Usage: run_journal.exe solve_simulation.py <sim_file_path> [tip_thickness] [support_angle]")
+        print("Usage: run_journal.exe solve_simulation.py <sim_file_path> [solution_name] [expr1=val1] [expr2=val2] ...")
         return False
 
     sim_file_path = args[0]
 
+    # Parse solution name if provided (args[1])
+    solution_name = args[1] if len(args) > 1 and args[1] != 'None' else None
+
     # Extract base name from sim file (e.g., "Beam_sim1.sim" -> "Beam")
     import os
     sim_filename = os.path.basename(sim_file_path)
     part_base_name = sim_filename.split('_sim')[0] if '_sim' in sim_filename else sim_filename.split('.sim')[0]
 
-    # Parse expression values if provided
-    tip_thickness = float(args[1]) if len(args) > 1 else None
-    support_angle = float(args[2]) if len(args) > 2 else None
+    # Parse expression updates from args[2+] as "name=value" pairs
+    expression_updates = {}
+    for arg in args[2:]:
+        if '=' in arg:
+            name, value = arg.split('=', 1)
+            expression_updates[name] = float(value)
 
     print(f"[JOURNAL] Opening simulation: {sim_file_path}")
     print(f"[JOURNAL] Detected part base name: {part_base_name}")
-    if tip_thickness is not None:
-        print(f"[JOURNAL] Will update tip_thickness = {tip_thickness}")
-    if support_angle is not None:
-        print(f"[JOURNAL] Will update support_angle = {support_angle}")
+    if solution_name:
+        print(f"[JOURNAL] Will solve specific solution: {solution_name}")
+    else:
+        print(f"[JOURNAL] Will solve default solution (Solution 1)")
+    if expression_updates:
+        print(f"[JOURNAL] Will update expressions:")
+        for name, value in expression_updates.items():
+            print(f"[JOURNAL]   {name} = {value}")
 
     try:
         theSession = NXOpen.Session.GetSession()
@@ -134,27 +144,21 @@ def main(args):
                 # CRITICAL: Apply expression changes BEFORE updating geometry
                 expressions_updated = []
 
-                if tip_thickness is not None:
-                    print(f"[JOURNAL]   Applying tip_thickness = {tip_thickness}")
-                    expr_tip = workPart.Expressions.FindObject("tip_thickness")
-                    if expr_tip:
-                        unit_mm = workPart.UnitCollection.FindObject("MilliMeter")
-                        workPart.Expressions.EditExpressionWithUnits(expr_tip, unit_mm, str(tip_thickness))
-                        expressions_updated.append(expr_tip)
-                        print(f"[JOURNAL]     tip_thickness updated")
-                    else:
-                        print(f"[JOURNAL]     WARNING: tip_thickness expression not found!")
-
-                if support_angle is not None:
-                    print(f"[JOURNAL]   Applying support_angle = {support_angle}")
-                    expr_angle = workPart.Expressions.FindObject("support_angle")
-                    if expr_angle:
-                        unit_deg = workPart.UnitCollection.FindObject("Degrees")
-                        workPart.Expressions.EditExpressionWithUnits(expr_angle, unit_deg, str(support_angle))
-                        expressions_updated.append(expr_angle)
-                        print(f"[JOURNAL]     support_angle updated")
-                    else:
-                        print(f"[JOURNAL]     WARNING: support_angle expression not found!")
+                # Apply all expression updates dynamically
+                for expr_name, expr_value in expression_updates.items():
+                    print(f"[JOURNAL]   Applying {expr_name} = {expr_value}")
+                    try:
+                        expr_obj = workPart.Expressions.FindObject(expr_name)
+                        if expr_obj:
+                            # Use millimeters as default unit for geometric parameters
+                            unit_mm = workPart.UnitCollection.FindObject("MilliMeter")
+                            workPart.Expressions.EditExpressionWithUnits(expr_obj, unit_mm, str(expr_value))
+                            expressions_updated.append(expr_obj)
+                            print(f"[JOURNAL]     {expr_name} updated successfully")
+                        else:
+                            print(f"[JOURNAL]     WARNING: {expr_name} expression not found!")
+                    except Exception as e:
+                        print(f"[JOURNAL]     ERROR updating {expr_name}: {e}")
 
                 # Make expressions up to date
                 if expressions_updated:
@@ -171,6 +175,20 @@ def main(args):
                 nErrs = theSession.UpdateManager.DoUpdate(markId_update)
                 theSession.DeleteUndoMark(markId_update, "NX update")
                 print(f"[JOURNAL]   {part_base_name} geometry updated ({nErrs} errors)")
+
+                # Extract mass from expression p173 if it exists and write to temp file
+                try:
+                    mass_expr = workPart.Expressions.FindObject("p173")
+                    if mass_expr:
+                        mass_kg = mass_expr.Value
+                        mass_output_file = os.path.join(working_dir, "_temp_mass.txt")
+                        with open(mass_output_file, 'w') as f:
+                            f.write(str(mass_kg))
+                        print(f"[JOURNAL]   Mass from p173: {mass_kg:.6f} kg ({mass_kg * 1000:.2f} g)")
+                        print(f"[JOURNAL]   Mass written to: {mass_output_file}")
+                except:
+                    pass  # Expression p173 might not exist in all models
+
                 geometry_updated = True
             else:
                 print(f"[JOURNAL]   {part_base_name} part not found - may be embedded in sim file")
@@ -247,31 +265,45 @@ def main(args):
 
         theCAESimSolveManager = NXOpen.CAE.SimSolveManager.GetSimSolveManager(theSession)
 
-        # Get the first solution from the simulation
+        # Get the simulation object
         simSimulation1 = workSimPart.FindObject("Simulation")
-        simSolution1 = simSimulation1.FindObject("Solution[Solution 1]")
 
-        psolutions1 = [simSolution1]
+        # Get the solution(s) to solve - either specific or all
+        if solution_name:
+            # Solve specific solution in background mode
+            solution_obj_name = f"Solution[{solution_name}]"
+            print(f"[JOURNAL] Looking for solution: {solution_obj_name}")
+            simSolution1 = simSimulation1.FindObject(solution_obj_name)
+            psolutions1 = [simSolution1]
 
-        # Solve in background mode
-        numsolutionssolved1, numsolutionsfailed1, numsolutionsskipped1 = theCAESimSolveManager.SolveChainOfSolutions(
-            psolutions1,
-            NXOpen.CAE.SimSolution.SolveOption.Solve,
-            NXOpen.CAE.SimSolution.SetupCheckOption.CompleteDeepCheckAndOutputErrors,
-            NXOpen.CAE.SimSolution.SolveMode.Background
-        )
+            numsolutionssolved1, numsolutionsfailed1, numsolutionsskipped1 = theCAESimSolveManager.SolveChainOfSolutions(
+                psolutions1,
+                NXOpen.CAE.SimSolution.SolveOption.Solve,
+                NXOpen.CAE.SimSolution.SetupCheckOption.CompleteDeepCheckAndOutputErrors,
+                NXOpen.CAE.SimSolution.SolveMode.Background
+            )
+        else:
+            # Solve ALL solutions using SolveAllSolutions API (Foreground mode)
+            # This ensures all solutions (static + modal, etc.) complete before returning
+            print(f"[JOURNAL] Solving all solutions using SolveAllSolutions API (Foreground mode)...")
+
+            numsolutionssolved1, numsolutionsfailed1, numsolutionsskipped1 = theCAESimSolveManager.SolveAllSolutions(
+                NXOpen.CAE.SimSolution.SolveOption.Solve,
+                NXOpen.CAE.SimSolution.SetupCheckOption.CompleteCheckAndOutputErrors,
+                NXOpen.CAE.SimSolution.SolveMode.Foreground,
+                False
+            )
 
         theSession.DeleteUndoMark(markId5, None)
         theSession.SetUndoMarkName(markId3, "Solve")
 
-        print(f"[JOURNAL] Solve submitted!")
+        print(f"[JOURNAL] Solve completed!")
         print(f"[JOURNAL]   Solutions solved: {numsolutionssolved1}")
         print(f"[JOURNAL]   Solutions failed: {numsolutionsfailed1}")
         print(f"[JOURNAL]   Solutions skipped: {numsolutionsskipped1}")
 
-        # NOTE: In Background mode, these values may not be accurate since the solve
-        # runs asynchronously. The solve will continue after this journal finishes.
-        # We rely on the Save operation and file existence checks to verify success.
+        # NOTE: When solution_name=None, we use Foreground mode to ensure all solutions
+        # complete before returning. When solution_name is specified, Background mode is used.
 
         # Save the simulation to write all output files
         print("[JOURNAL] Saving simulation to ensure output files are written...")