pdd-cli 0.0.24__py3-none-any.whl → 0.0.25__py3-none-any.whl

pdd/fix_verification_errors_loop.py

@@ -1,161 +1,80 @@
-# -*- coding: utf-8 -*-
-"""
-Module for iteratively fixing code verification errors using LLMs.
-"""
-
 import os
-import subprocess
 import shutil
-import time
+import subprocess
 import datetime
-import xml.etree.ElementTree as ET
-from xml.dom import minidom
-import tempfile
-from typing import Dict, Any, Tuple, Optional
+import time
+from pathlib import Path
+from typing import Dict, Tuple, Any, Optional
+from xml.sax.saxutils import escape
 
-# Use Rich for pretty console output
 from rich.console import Console
-from rich.panel import Panel
-from rich.syntax import Syntax
-from rich.text import Text
 
-# --- Internal Module Imports ---
-# Attempt relative import for package structure
+# Use relative import assuming fix_verification_errors is in the same package
 try:
+    # Attempt relative import for package context
     from .fix_verification_errors import fix_verification_errors
-    from .utils import ensure_dir_exists # Assuming a utility function exists
 except ImportError:
-    # Fallback for standalone execution or different structure
-    # This might indicate a setup issue if running as part of the package
-    print("Warning: Could not perform relative import. Falling back.")
-    # If fix_verification_errors is in the same directory or PYTHONPATH:
+    # Fallback for direct script execution (e.g., testing)
+    # This assumes 'pdd' package structure exists relative to the script
     try:
-        from fix_verification_errors import fix_verification_errors
-    except ImportError as e:
+        from pdd.fix_verification_errors import fix_verification_errors
+    except ImportError:
         raise ImportError(
             "Could not import 'fix_verification_errors'. "
-            "Ensure it's in the correct path or package structure."
-        ) from e
-    # Define a dummy ensure_dir_exists if not available
-    def ensure_dir_exists(file_path: str):
-        """Ensure the directory for the given file path exists."""
-        directory = os.path.dirname(file_path)
-        if directory and not os.path.exists(directory):
-            os.makedirs(directory)
-
-# Initialize Rich Console
-console = Console()
+            "Ensure it's available via relative import or in the 'pdd' package."
+        )
 
-# --- Helper Functions ---
+# Initialize Rich Console for pretty printing
+console = Console()
 
-def _run_subprocess(command: list[str], cwd: Optional[str] = None) -> Tuple[bool, str, int]:
+def _run_program(
+    program_path: Path,
+    args: Optional[list[str]] = None,
+    timeout: int = 60
+) -> Tuple[int, str]:
     """
-    Runs a subprocess command and captures its output.
+    Runs a Python program using subprocess, capturing combined stdout and stderr.
 
     Args:
-        command: A list of strings representing the command and its arguments.
-        cwd: The working directory to run the command in.
+        program_path: Path to the Python program to run.
+        args: Optional list of command-line arguments for the program.
+        timeout: Timeout in seconds for the subprocess.
 
     Returns:
-        A tuple containing:
-        - success (bool): True if the command exited with code 0, False otherwise.
-        - output (str): The combined stdout and stderr of the command.
-        - return_code (int): The exit code of the command.
+        A tuple containing the return code (int) and the combined output (str).
+        Returns (-1, error_message) if the program is not found or other execution error occurs.
     """
+    if not program_path.is_file():
+        return -1, f"Error: Program file not found at {program_path}"
+
+    command = ["python", str(program_path)]
+    if args:
+        command.extend(args)
+
     try:
-        process = subprocess.run(
+        result = subprocess.run(
             command,
             capture_output=True,
             text=True,
-            check=False, # Don't raise exception on non-zero exit
-            cwd=cwd,
-            encoding='utf-8',
-            errors='replace' # Handle potential encoding errors
+            timeout=timeout,
+            check=False,  # Don't raise exception for non-zero exit codes
         )
-        output = process.stdout + process.stderr
-        success = process.returncode == 0
-        return success, output.strip(), process.returncode
-    except FileNotFoundError:
-        error_msg = f"Error: Command not found: '{command[0]}'. Please ensure it's installed and in PATH."
-        console.print(f"[bold red]{error_msg}[/bold red]")
-        return False, error_msg, -1 # Use -1 to indicate execution failure
-    except Exception as e:
-        error_msg = f"Error running subprocess {' '.join(command)}: {e}"
-        console.print(f"[bold red]{error_msg}[/bold red]")
-        return False, error_msg, -1
-
-def _read_file(file_path: str) -> Optional[str]:
-    """Reads the content of a file."""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            return f.read()
+        combined_output = result.stdout + result.stderr
+        return result.returncode, combined_output
     except FileNotFoundError:
-        console.print(f"[bold red]Error: File not found: {file_path}[/bold red]")
-        return None
-    except Exception as e:
-        console.print(f"[bold red]Error reading file {file_path}: {e}[/bold red]")
-        return None
-
-def _write_file(file_path: str, content: str) -> bool:
-    """Writes content to a file."""
-    try:
-        ensure_dir_exists(file_path)
-        with open(file_path, 'w', encoding='utf-8') as f:
-            f.write(content)
-        return True
+        return -1, f"Error: Python interpreter not found or '{program_path}' not found."
+    except subprocess.TimeoutExpired:
+        return -1, f"Error: Program execution timed out after {timeout} seconds."
     except Exception as e:
-        console.print(f"[bold red]Error writing file {file_path}: {e}[/bold red]")
-        return False
-
-def _create_backup(file_path: str, iteration: int) -> Optional[str]:
-    """Creates a backup copy of a file."""
-    if not os.path.exists(file_path):
-        console.print(f"[yellow]Warning: Cannot backup non-existent file: {file_path}[/yellow]")
-        return None
-    try:
-        base, ext = os.path.splitext(file_path)
-        backup_path = f"{base}_iteration_{iteration}{ext}"
-        shutil.copy2(file_path, backup_path) # copy2 preserves metadata
-        return backup_path
-    except Exception as e:
-        console.print(f"[bold red]Error creating backup for {file_path}: {e}[/bold red]")
-        return None
-
-def _restore_backup(backup_path: str, original_path: str) -> bool:
-    """Restores a file from its backup."""
-    if not backup_path or not os.path.exists(backup_path):
-        console.print(f"[bold red]Error: Backup file not found: {backup_path}[/bold red]")
-        return False
-    try:
-        shutil.copy2(backup_path, original_path)
-        return True
-    except Exception as e:
-        console.print(f"[bold red]Error restoring {original_path} from {backup_path}: {e}[/bold red]")
-        return False
+        return -1, f"Error: An unexpected error occurred while running the program: {e}"
 
-def _append_log_entry(log_file: str, root_element: ET.Element, entry_element: ET.Element):
-    """Appends an XML element to the log file."""
+def _write_log_entry(log_file_path: Path, xml_content: str):
+    """Appends XML content to the log file."""
     try:
-        ensure_dir_exists(log_file)
-        root_element.append(entry_element)
-        # Use minidom for pretty printing XML
-        rough_string = ET.tostring(root_element, 'utf-8')
-        reparsed = minidom.parseString(rough_string)
-        pretty_xml = reparsed.toprettyxml(indent="  ", encoding='utf-8')
-
-        with open(log_file, 'wb') as f: # Write bytes for encoded XML
-            f.write(pretty_xml)
-    except Exception as e:
-        console.print(f"[bold red]Error writing to XML log file {log_file}: {e}[/bold red]")
-
-def _create_cdata_element(parent: ET.Element, tag_name: str, content: Optional[str]):
-    """Creates an XML element with CDATA content."""
-    element = ET.SubElement(parent, tag_name)
-    # Use a placeholder if content is None or empty to ensure valid XML structure
-    element.text = ET.CDATA(content if content is not None else "")
-
-
-# --- Main Function ---
+        with open(log_file_path, "a", encoding="utf-8") as f:
+            f.write(xml_content + "\n")
+    except IOError as e:
+        console.print(f"[bold red]Error writing to log file {log_file_path}: {e}[/bold red]")
 
 def fix_verification_errors_loop(
     program_file: str,
@@ -166,736 +85,891 @@ def fix_verification_errors_loop(
     temperature: float,
     max_attempts: int,
     budget: float,
-    verification_log_file: str = "verification_log.xml",
-    verbose: bool = False
+    verification_log_file: str = "verification.log",
+    verbose: bool = False,
+    program_args: Optional[list[str]] = None,
 ) -> Dict[str, Any]:
     """
-    Attempts to fix errors in a code file iteratively based on program execution.
+    Attempts to fix errors in a code file based on program execution output
+    against the prompt's intent, iterating multiple times with secondary verification.
 
     Args:
-        program_file: Path to the Python program file that exercises the code_file.
+        program_file: Path to the Python program exercising the code.
         code_file: Path to the code file being tested/verified.
-        prompt: The prompt that generated the code under test.
-        verification_program: Path to a secondary Python program for basic verification.
-        strength: LLM strength parameter (0.0 to 1.0).
-        temperature: LLM temperature parameter (>= 0.0).
+        prompt: The prompt defining the intended behavior.
+        verification_program: Path to a secondary program to verify code changes.
+        strength: LLM model strength (0.0 to 1.0).
+        temperature: LLM temperature (0.0 to 1.0).
         max_attempts: Maximum number of fix attempts.
-        budget: Maximum allowed cost for LLM calls.
-        verification_log_file: Path for detailed XML logging.
-        verbose: Enable detailed console logging.
+        budget: Maximum allowed cost in USD.
+        verification_log_file: Path for detailed XML logging (default: "verification.log").
+        verbose: Enable verbose logging (default: False).
+        program_args: Optional list of command-line arguments for the program_file.
 
     Returns:
         A dictionary containing:
-        - 'success': bool - True if the code was successfully fixed.
-        - 'final_program': str - Contents of the final program file.
-        - 'final_code': str - Contents of the final code file.
-        - 'total_attempts': int - Number of fix attempts made.
-        - 'total_cost': float - Total cost incurred.
-        - 'model_name': str | None - Name of the LLM model used (last successful call).
-        - 'statistics': dict - Detailed statistics about the process.
+            'success': bool - Whether the code was successfully fixed.
+            'final_program': str - Contents of the final program file.
+            'final_code': str - Contents of the final code file.
+            'total_attempts': int - Number of fix attempts made (loop iterations started).
+            'total_cost': float - Total cost of LLM calls.
+            'model_name': str | None - Name of the LLM model used.
+            'statistics': dict - Detailed statistics about the process.
     """
-    console.print(Panel(f"Starting Verification Fix Loop for [cyan]{code_file}[/cyan]", title="[bold blue]Process Start[/bold blue]", expand=False))
-
-    # --- Step 1: Initialize Log File ---
-    if os.path.exists(verification_log_file):
-        try:
-            os.remove(verification_log_file)
+    program_path = Path(program_file).resolve()
+    code_path = Path(code_file).resolve()
+    verification_program_path = Path(verification_program).resolve()
+    log_path = Path(verification_log_file).resolve()
+
+    # --- Validate Inputs ---
+    if not program_path.is_file():
+        console.print(f"[bold red]Error: Program file not found: {program_path}[/bold red]")
+        return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": {}}
+    if not code_path.is_file():
+        console.print(f"[bold red]Error: Code file not found: {code_path}[/bold red]")
+        return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": {}}
+    if not verification_program_path.is_file():
+        console.print(f"[bold red]Error: Verification program not found: {verification_program_path}[/bold red]")
+        return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": {}}
+    if not 0.0 <= strength <= 1.0:
+        console.print(f"[bold red]Error: Strength must be between 0.0 and 1.0.[/bold red]")
+        return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": {}}
+    if not 0.0 <= temperature <= 1.0:
+         console.print(f"[bold red]Error: Temperature must be between 0.0 and 1.0.[/bold red]")
+         return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": {}}
+    # Prompt requires positive max_attempts
+    if max_attempts <= 0:
+        console.print(f"[bold red]Error: Max attempts must be positive.[/bold red]")
+        return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": {}}
+    if budget < 0:
+        console.print(f"[bold red]Error: Budget cannot be negative.[/bold red]")
+        return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": {}}
+
+
+    # Step 1: Remove existing verification log file
+    try:
+        if log_path.exists():
+            os.remove(log_path)
             if verbose:
-                console.print(f"Removed existing log file: {verification_log_file}")
-        except OSError as e:
-            console.print(f"[bold red]Error removing existing log file {verification_log_file}: {e}[/bold red]")
-            # Continue execution, but logging might be appended or fail later
-    log_root = ET.Element("VerificationLog")
-    log_root.set("startTime", datetime.datetime.now().isoformat())
+                console.print(f"Removed existing log file: {log_path}")
+    except OSError as e:
+        console.print(f"[bold red]Error removing log file {log_path}: {e}[/bold red]")
+        # Continue execution, but logging might fail
 
-    # --- Step 2: Initialize Variables ---
-    attempts = 0
+    # Step 2: Initialize variables
+    attempts = 0 # Counter for loop iterations started
     total_cost = 0.0
     model_name: Optional[str] = None
     overall_success = False
-    last_fix_result: Optional[Dict[str, Any]] = None # Store the result of the last fix attempt
-
-    # Best iteration tracker: Stores the state with the minimum verified issues
     best_iteration = {
-        'attempt': -1, # -1 means initial state, 0+ for loop iterations
-        'issues': float('inf'),
-        'program_backup_path': None,
-        'code_backup_path': None,
-        'model_name': None,
+        'attempt': -1, # 0 represents initial state
+        'program_backup': None,
+        'code_backup': None,
+        'issues': float('inf')
     }
-
-    # Statistics tracker
     stats = {
-        'initial_issues': -1, # -1 indicates not yet determined
+        'initial_issues': -1,
         'final_issues': -1,
-        'best_iteration_attempt': -1,
+        'best_iteration_num': -1,
         'best_iteration_issues': float('inf'),
         'improvement_issues': 0,
-        'overall_success_flag': False,
-        'exit_reason': "Unknown",
+        'improvement_percent': 0.0,
+        'status_message': 'Initialization',
     }
-
-    # --- Input Validation ---
-    if not os.path.isfile(program_file):
-        console.print(f"[bold red]Error: Program file not found: {program_file}[/bold red]")
-        stats['exit_reason'] = "Input Error: Program file not found"
-        return {
-            'success': False, 'final_program': "", 'final_code': "",
-            'total_attempts': 0, 'total_cost': 0.0, 'model_name': None,
-            'statistics': stats
-        }
-    if not os.path.isfile(code_file):
-        console.print(f"[bold red]Error: Code file not found: {code_file}[/bold red]")
-        stats['exit_reason'] = "Input Error: Code file not found"
-        return {
-            'success': False, 'final_program': "", 'final_code': "",
-            'total_attempts': 0, 'total_cost': 0.0, 'model_name': None,
-            'statistics': stats
-        }
-    if not os.path.isfile(verification_program):
-        console.print(f"[bold red]Error: Secondary verification program not found: {verification_program}[/bold red]")
-        stats['exit_reason'] = "Input Error: Verification program not found"
-        return {
-            'success': False, 'final_program': "", 'final_code': "",
-            'total_attempts': 0, 'total_cost': 0.0, 'model_name': None,
-            'statistics': stats
-        }
+    initial_program_content = ""
+    initial_code_content = ""
+    program_contents = "" # Keep track of current contents
+    code_contents = ""    # Keep track of current contents
 
     # --- Step 3: Determine Initial State ---
     if verbose:
-        console.print("\n[bold]Step 3: Determining Initial State[/bold]")
+        console.print("[bold cyan]Step 3: Determining Initial State...[/bold cyan]")
 
-    # 3a: Run initial program
-    initial_run_success, initial_output, _ = _run_subprocess(['python', program_file])
+    try:
+        initial_program_content = program_path.read_text(encoding="utf-8")
+        initial_code_content = code_path.read_text(encoding="utf-8")
+        program_contents = initial_program_content # Initialize current contents
+        code_contents = initial_code_content       # Initialize current contents
+    except IOError as e:
+        console.print(f"[bold red]Error reading initial program/code files: {e}[/bold red]")
+        stats['status_message'] = f'Error reading initial files: {e}' # Add status message
+        return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": stats}
+
+    # 3a: Run initial program with args
+    initial_return_code, initial_output = _run_program(program_path, args=program_args)
     if verbose:
-        console.print(f"Initial program execution {'succeeded' if initial_run_success else 'failed'}.")
-        console.print("[dim]Initial Output:[/dim]")
-        console.print(f"[grey37]{initial_output or '[No Output]'}[/grey37]")
+        console.print(f"Initial program run exit code: {initial_return_code}")
+        console.print(f"Initial program output:\n{initial_output}")
 
     # 3b: Log initial state
-    initial_state_log = ET.Element("InitialState")
-    initial_state_log.set("timestamp", datetime.datetime.now().isoformat())
-    _create_cdata_element(initial_state_log, "InitialProgramOutput", initial_output)
-    _append_log_entry(verification_log_file, log_root, initial_state_log)
-
-    # 3c: Read initial contents
-    initial_program_contents = _read_file(program_file)
-    initial_code_contents = _read_file(code_file)
-    if initial_program_contents is None or initial_code_contents is None:
-        stats['exit_reason'] = "File Read Error: Could not read initial program or code file."
-        return {
-            'success': False, 'final_program': initial_program_contents or "", 'final_code': initial_code_contents or "",
-            'total_attempts': 0, 'total_cost': 0.0, 'model_name': None,
-            'statistics': stats
-        }
+    timestamp = datetime.datetime.now().isoformat()
+    initial_log_entry = f'<InitialState timestamp="{timestamp}">\n'
+    initial_log_entry += f'  <ProgramFile>{escape(str(program_path))}</ProgramFile>\n'
+    initial_log_entry += f'  <CodeFile>{escape(str(code_path))}</CodeFile>\n'
+    initial_log_entry += f'  <ExitCode>{initial_return_code}</ExitCode>\n'
+    initial_log_entry += f'  <Output>{escape(initial_output)}</Output>\n'
+    initial_log_entry += '</InitialState>'
+    _write_log_entry(log_path, initial_log_entry)
 
     # 3d: Call fix_verification_errors for initial assessment
-    if verbose:
-        console.print("Running initial assessment with 'fix_verification_errors'...")
     try:
-        # Use provided strength/temp for consistency, but check budget
-        if budget <= 0:
-             console.print("[bold yellow]Warning: Initial budget is zero or negative. Skipping initial assessment.[/bold yellow]")
-             initial_fix_result = {'total_cost': 0.0, 'verification_issues_count': float('inf'), 'model_name': None, 'explanation': ['Skipped due to budget']} # Mock result
-        else:
-            initial_fix_result = fix_verification_errors(
-                program=initial_program_contents,
-                prompt=prompt,
-                code=initial_code_contents,
-                output=initial_output,
-                strength=strength, # Use actual strength/temp for initial check
-                temperature=temperature,
-                verbose=verbose # Pass verbose flag down
-            )
-        last_fix_result = initial_fix_result # Store for potential later use
-    except Exception as e:
-        console.print(f"[bold red]Error during initial call to fix_verification_errors: {e}[/bold red]")
-        stats['exit_reason'] = f"LLM Error: Initial fix_verification_errors call failed: {e}"
-        # Log the error
-        error_log = ET.Element("Error")
-        error_log.set("timestamp", datetime.datetime.now().isoformat())
-        error_log.set("phase", "InitialAssessment")
-        _create_cdata_element(error_log, "ErrorMessage", str(e))
-        _append_log_entry(verification_log_file, log_root, error_log)
-        return {
-            'success': False, 'final_program': initial_program_contents, 'final_code': initial_code_contents,
-            'total_attempts': 0, 'total_cost': total_cost, 'model_name': model_name,
-            'statistics': stats
-        }
+        if verbose:
+            console.print("Running initial assessment with fix_verification_errors...")
+        # Use actual strength/temp for realistic initial assessment
+        initial_fix_result = fix_verification_errors(
+            program=initial_program_content,
+            prompt=prompt,
+            code=initial_code_content,
+            output=initial_output,
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+        # 3e: Add cost
+        initial_cost = initial_fix_result.get('total_cost', 0.0)
+        total_cost += initial_cost
+        model_name = initial_fix_result.get('model_name') # Capture model name early
+        if verbose:
+             console.print(f"Initial assessment cost: ${initial_cost:.6f}, Total cost: ${total_cost:.6f}")
 
+        # 3f: Extract initial issues
+        initial_issues_count = initial_fix_result.get('verification_issues_count', -1)
+        stats['initial_issues'] = initial_issues_count
+        if verbose:
+            console.print(f"Initial verification issues found: {initial_issues_count}")
+            if initial_fix_result.get('explanation'):
+                 console.print("Initial assessment explanation:")
+                 console.print(initial_fix_result['explanation'])
+
+        # FIX: Add check for initial assessment error *before* checking success/budget
+        # Check if the fixer function returned its specific error state (None explanation/model)
+        if initial_fix_result.get('explanation') is None and initial_fix_result.get('model_name') is None:
+             error_msg = "Error: Fixer returned invalid/error state during initial assessment"
+             console.print(f"[bold red]{error_msg}. Aborting.[/bold red]")
+             stats['status_message'] = error_msg
+             stats['final_issues'] = -1 # Indicate unknown/error state
+             # Write final action log for error on initial check
+             final_log_entry = "<FinalActions>\n"
+             final_log_entry += f'  <Error>{escape(error_msg)}</Error>\n'
+             final_log_entry += "</FinalActions>"
+             _write_log_entry(log_path, final_log_entry)
+             # Return failure state
+             return {
+                 "success": False,
+                 "final_program": initial_program_content,
+                 "final_code": initial_code_content,
+                 "total_attempts": 0,
+                 "total_cost": total_cost, # May be non-zero if error occurred after some cost
+                 "model_name": model_name, # May have been set before error
+                 "statistics": stats,
+             }
+
+        # 3g: Initialize best iteration tracker
+        # Store original paths as the 'backup' for iteration 0
+        best_iteration = {
+            'attempt': 0, # Use 0 for initial state
+            'program_backup': str(program_path), # Path to original
+            'code_backup': str(code_path),       # Path to original
+            'issues': initial_issues_count if initial_issues_count != -1 else float('inf')
+        }
+        stats['best_iteration_num'] = 0
+        stats['best_iteration_issues'] = best_iteration['issues']
+
+        # 3h: Check for immediate success or budget exceeded
+        if initial_issues_count == 0:
+            console.print("[bold green]Initial check found 0 verification issues. No fixing loop needed.[/bold green]")
+            overall_success = True
+            stats['final_issues'] = 0
+            stats['status_message'] = 'Success on initial check'
+            stats['improvement_issues'] = 0
+            stats['improvement_percent'] = 100.0 # Reached target of 0 issues
+
+            # Write final action log for successful initial check
+            final_log_entry = "<FinalActions>\n"
+            final_log_entry += f'  <Action>Process finished successfully on initial check.</Action>\n'
+            final_log_entry += "</FinalActions>"
+            _write_log_entry(log_path, final_log_entry)
+
+            # Step 7 (early exit): Print stats
+            console.print("\n[bold]--- Final Statistics ---[/bold]")
+            console.print(f"Initial Issues: {stats['initial_issues']}")
+            console.print(f"Final Issues: {stats['final_issues']}")
+            console.print(f"Best Iteration: {stats['best_iteration_num']} (Issues: {stats['best_iteration_issues']})")
+            console.print(f"Improvement (Issues Reduced): {stats['improvement_issues']}")
+            console.print(f"Improvement (Percent Towards 0 Issues): {stats['improvement_percent']:.2f}%")
+            console.print(f"Overall Status: {stats['status_message']}")
+            console.print(f"Total Attempts Made: {attempts}") # attempts is 0 here
+            console.print(f"Total Cost: ${total_cost:.6f}")
+            console.print(f"Model Used: {model_name or 'N/A'}")
+            # Step 8 (early exit): Return
+            return {
+                "success": overall_success,
+                "final_program": initial_program_content,
+                "final_code": initial_code_content,
+                "total_attempts": attempts, # attempts is 0
+                "total_cost": total_cost,
+                "model_name": model_name,
+                "statistics": stats,
+            }
+        elif total_cost >= budget:
+             console.print(f"[bold yellow]Budget ${budget:.4f} exceeded during initial assessment (Cost: ${total_cost:.4f}). Aborting.[/bold yellow]")
+             stats['status_message'] = 'Budget exceeded on initial check'
+             stats['final_issues'] = stats['initial_issues'] # Final issues same as initial
+
+             # Write final action log for budget exceeded on initial check
+             final_log_entry = "<FinalActions>\n"
+             final_log_entry += f'  <Action>Budget exceeded on initial check.</Action>\n'
+             final_log_entry += "</FinalActions>"
+             _write_log_entry(log_path, final_log_entry)
+
+             # No changes made, return initial state
+             return {
+                 "success": False,
+                 "final_program": initial_program_content,
+                 "final_code": initial_code_content,
+                 "total_attempts": 0,
+                 "total_cost": total_cost,
+                 "model_name": model_name,
+                 "statistics": stats,
+             }
 
-    # 3e: Add cost
-    initial_cost = initial_fix_result.get('total_cost', 0.0)
-    total_cost += initial_cost
-    model_name = initial_fix_result.get('model_name', model_name) # Update model name
+    except Exception as e:
+        console.print(f"[bold red]Error during initial assessment with fix_verification_errors: {e}[/bold red]")
+        stats['status_message'] = f'Error during initial assessment: {e}'
+        # Cannot proceed without initial assessment
+        return {"success": False, "final_program": initial_program_content, "final_code": initial_code_content, "total_attempts": 0, "total_cost": total_cost, "model_name": model_name, "statistics": stats}
 
-    # 3f: Extract initial issues
-    initial_issues_count = initial_fix_result.get('verification_issues_count', float('inf'))
-    if initial_issues_count == float('inf'):
-         console.print("[yellow]Warning: Could not determine initial issue count from fix_verification_errors.[/yellow]")
-         # Decide how to handle this - maybe treat as high number of issues?
-         initial_issues_count = 999 # Assign a high number if undetermined
 
-    stats['initial_issues'] = initial_issues_count
+    # --- Step 4: Enter the Fixing Loop ---
     if verbose:
-        console.print(f"Initial assessment complete. Issues found: {initial_issues_count}, Cost: ${initial_cost:.6f}")
-
-    # 3g: Initialize best iteration with initial state
-    best_iteration['attempt'] = 0 # Representing the initial state before loop
-    best_iteration['issues'] = initial_issues_count
-    best_iteration['program_backup_path'] = program_file # Original file path
-    best_iteration['code_backup_path'] = code_file     # Original file path
-    best_iteration['model_name'] = model_name
-
-    # Log initial assessment details
-    initial_assessment_log = ET.Element("InitialAssessment")
-    initial_assessment_log.set("timestamp", datetime.datetime.now().isoformat())
-    initial_assessment_log.set("issues_found", str(initial_issues_count))
-    initial_assessment_log.set("cost", f"{initial_cost:.6f}")
-    if model_name:
-         initial_assessment_log.set("model_name", model_name)
-    _create_cdata_element(initial_assessment_log, "Explanation", "\n".join(initial_fix_result.get('explanation', [])))
-    _append_log_entry(verification_log_file, log_root, initial_assessment_log)
-
-
-    # 3h: Check if already successful
-    if initial_issues_count == 0:
-        console.print("[bold green]Initial state already meets verification criteria (0 issues found). No fixing loop needed.[/bold green]")
-        overall_success = True
-        stats['final_issues'] = 0
-        stats['best_iteration_attempt'] = 0
-        stats['best_iteration_issues'] = 0
-        stats['improvement_issues'] = 0
-        stats['overall_success_flag'] = True
-        stats['exit_reason'] = "Success on Initial Assessment"
-        # Skip to Step 7/8 (Return)
-
-    # --- Step 4: Fixing Loop ---
-    current_program_contents = initial_program_contents
-    current_code_contents = initial_code_contents
-
-    if not overall_success: # Only enter loop if initial state wasn't perfect
+        console.print("\n[bold cyan]Step 4: Starting Fixing Loop...[/bold cyan]")
+
+    # Loop while attempts < max_attempts and budget not exceeded
+    # Note: The loop condition checks attempts *before* incrementing for the current iteration
+    while attempts < max_attempts:
+        current_attempt = attempts + 1 # 1-based for reporting
+        timestamp = datetime.datetime.now().isoformat()
+        iteration_log_xml = f'<Iteration attempt="{current_attempt}" timestamp="{timestamp}">\n'
+
+        # 4a: Print attempt number and increment counter for attempts *started*
+        console.print(f"\n[bold]Attempt {current_attempt}/{max_attempts} (Cost: ${total_cost:.4f}/{budget:.4f})[/bold]")
+        attempts += 1 # Increment attempts counter here for iterations started
+
+        # Check budget *before* running expensive operations in the loop
+        if total_cost >= budget:
+            console.print(f"[bold yellow]Budget ${budget:.4f} already met or exceeded before starting attempt {current_attempt}. Stopping.[/bold yellow]")
+            # No iteration log entry needed as the iteration didn't run
+            stats['status_message'] = 'Budget Exceeded'
+            attempts -= 1 # Decrement as this attempt didn't actually run
+            break
+
+        # 4b: Run the program file with args
         if verbose:
-            console.print(f"\n[bold]Step 4: Starting Fixing Loop (Max Attempts: {max_attempts}, Budget: ${budget:.2f})[/bold]")
-
-        while attempts < max_attempts and total_cost < budget:
-            attempt_number = attempts + 1
-            if verbose:
-                console.print(f"\n--- Attempt {attempt_number}/{max_attempts} --- Cost so far: ${total_cost:.6f}")
-
-            # 4a: Log attempt start (done within iteration log)
-            iteration_log = ET.Element("Iteration")
-            iteration_log.set("attempt", str(attempt_number))
-            iteration_log.set("timestamp", datetime.datetime.now().isoformat())
-
-            # 4b: Run the program file
-            run_success, program_output, _ = _run_subprocess(['python', program_file])
+            console.print(f"Running program: {program_path} with args: {program_args}")
+        return_code, program_output = _run_program(program_path, args=program_args)
+        iteration_log_xml += f'  <ProgramExecution>\n'
+        iteration_log_xml += f'    <ExitCode>{return_code}</ExitCode>\n'
+        iteration_log_xml += f'    <OutputBeforeFix>{escape(program_output)}</OutputBeforeFix>\n'
+        iteration_log_xml += f'  </ProgramExecution>\n'
+        if verbose:
+            console.print(f"Program exit code: {return_code}")
+            # console.print(f"Program output:\n{program_output}") # Can be long
+
+        # 4c: Read current contents (already stored in program_contents/code_contents)
+        # Re-read could be added here if external modification is possible, but generally not needed
+        # try:
+        #     program_contents = program_path.read_text(encoding="utf-8")
+        #     code_contents = code_path.read_text(encoding="utf-8")
+        # except IOError as e: ...
+
+        # 4d: Create backups
+        program_backup_path = program_path.with_stem(f"{program_path.stem}_iteration_{current_attempt}").with_suffix(program_path.suffix)
+        code_backup_path = code_path.with_stem(f"{code_path.stem}_iteration_{current_attempt}").with_suffix(code_path.suffix)
+        try:
+            # Copy from the *current* state before this iteration's fix
+            program_path.write_text(program_contents, encoding="utf-8") # Ensure file matches memory state
+            code_path.write_text(code_contents, encoding="utf-8")       # Ensure file matches memory state
+            shutil.copy2(program_path, program_backup_path)
+            shutil.copy2(code_path, code_backup_path)
             if verbose:
-                console.print(f"Program execution {'succeeded' if run_success else 'failed'}.")
-                # console.print("[dim]Current Output:[/dim]")
-                # console.print(f"[grey37]{program_output or '[No Output]'}[/grey37]") # Can be very long
-
-            _create_cdata_element(iteration_log, "ProgramOutputBeforeFix", program_output)
-
-            # 4c: Read current contents (already stored in current_*)
-
-            # 4d: Create backups
-            program_backup_path = _create_backup(program_file, attempt_number)
-            code_backup_path = _create_backup(code_file, attempt_number)
-            if program_backup_path: iteration_log.set("program_backup", program_backup_path)
-            if code_backup_path: iteration_log.set("code_backup", code_backup_path)
-
-            # 4e: Call fix_verification_errors
+                console.print(f"Created backups: {program_backup_path}, {code_backup_path}")
+            iteration_log_xml += f'  <Backups>\n'
+            iteration_log_xml += f'    <Program>{escape(str(program_backup_path))}</Program>\n'
+            iteration_log_xml += f'    <Code>{escape(str(code_backup_path))}</Code>\n'
+            iteration_log_xml += f'  </Backups>\n'
+        except OSError as e:
+            console.print(f"[bold red]Error creating backup files during attempt {current_attempt}: {e}[/bold red]")
+            iteration_log_xml += f'  <Status>Error Creating Backups</Status>\n</Iteration>'
+            _write_log_entry(log_path, iteration_log_xml)
+            stats['status_message'] = f'Error creating backups on attempt {current_attempt}'
+            break # Don't proceed without backups
+
+        # 4e: Call fix_verification_errors
+        iteration_log_xml += f'  <InputsToFixer>\n'
+        iteration_log_xml += f'    <Program>{escape(program_contents)}</Program>\n'
+        iteration_log_xml += f'    <Code>{escape(code_contents)}</Code>\n'
+        iteration_log_xml += f'    <Prompt>{escape(prompt)}</Prompt>\n'
+        iteration_log_xml += f'    <ProgramOutput>{escape(program_output)}</ProgramOutput>\n'
+        iteration_log_xml += f'  </InputsToFixer>\n'
+
+        fix_result = {}
+        try:
             if verbose:
-                console.print("Calling 'fix_verification_errors' to suggest fixes...")
-            try:
-                fix_result = fix_verification_errors(
-                    program=current_program_contents,
-                    prompt=prompt,
-                    code=current_code_contents,
-                    output=program_output,
-                    strength=strength,
-                    temperature=temperature,
-                    verbose=verbose # Pass verbose flag down
-                )
-                last_fix_result = fix_result # Store latest result
-            except Exception as e:
-                console.print(f"[bold red]Error during fix_verification_errors call in attempt {attempt_number}: {e}[/bold red]")
-                stats['exit_reason'] = f"LLM Error: fix_verification_errors failed in loop: {e}"
-                # Log the error and break
-                error_log = ET.Element("Error")
-                error_log.set("timestamp", datetime.datetime.now().isoformat())
-                error_log.set("phase", f"FixAttempt_{attempt_number}")
-                _create_cdata_element(error_log, "ErrorMessage", str(e))
-                _append_log_entry(verification_log_file, log_root, error_log)
-                break # Exit loop on LLM error
-
-            # Log inputs and results to XML
-            inputs_log = ET.SubElement(iteration_log, "InputsToFixer")
-            _create_cdata_element(inputs_log, "Program", current_program_contents)
-            _create_cdata_element(inputs_log, "Code", current_code_contents)
-            _create_cdata_element(inputs_log, "Prompt", prompt)
-            _create_cdata_element(inputs_log, "ProgramOutput", program_output)
-
-            fixer_result_log = ET.SubElement(iteration_log, "FixerResult")
-            fixer_result_log.set("cost", f"{fix_result.get('total_cost', 0.0):.6f}")
-            fixer_result_log.set("model_name", fix_result.get('model_name', "Unknown"))
-            fixer_result_log.set("issues_found", str(fix_result.get('verification_issues_count', 'inf')))
-            _create_cdata_element(fixer_result_log, "Explanation", "\n".join(fix_result.get('explanation', [])))
-            _create_cdata_element(fixer_result_log, "FixedProgramSuggestion", fix_result.get('fixed_program'))
-            _create_cdata_element(fixer_result_log, "FixedCodeSuggestion", fix_result.get('fixed_code'))
+                console.print("Calling fix_verification_errors...")
+            fix_result = fix_verification_errors(
+                program=program_contents,
+                prompt=prompt,
+                code=code_contents,
+                output=program_output,
+                strength=strength,
+                temperature=temperature,
+                verbose=verbose # Pass verbose flag down
+            )
 
             # 4f: Add cost
             attempt_cost = fix_result.get('total_cost', 0.0)
             total_cost += attempt_cost
-            model_name = fix_result.get('model_name', model_name) # Update model name if available
-            if verbose:
-                console.print(f"Fix attempt cost: ${attempt_cost:.6f}, Total cost: ${total_cost:.6f}")
-                console.print(f"Issues found by fixer: {fix_result.get('verification_issues_count', 'N/A')}")
-
-
-            # 4h: Check budget
-            if total_cost > budget:
-                console.print(f"[bold yellow]Budget exceeded (${total_cost:.2f} > ${budget:.2f}). Stopping.[/bold yellow]")
-                status_log = ET.SubElement(iteration_log, "Status")
-                status_log.text = "Budget Exceeded"
-                _append_log_entry(verification_log_file, log_root, iteration_log)
-                stats['exit_reason'] = "Budget Exceeded"
-                break
-
-            # 4i: Check for success (0 issues)
-            current_issues_count = fix_result.get('verification_issues_count', float('inf'))
-            if current_issues_count == 0:
-                console.print("[bold green]Success! Fixer reported 0 verification issues.[/bold green]")
-                status_log = ET.SubElement(iteration_log, "Status")
-                status_log.text = "Success - 0 Issues Found"
-
-                # Update best iteration (0 issues is always the best)
-                best_iteration['attempt'] = attempt_number
-                best_iteration['issues'] = 0
-                best_iteration['program_backup_path'] = program_backup_path # Backup before successful fix
-                best_iteration['code_backup_path'] = code_backup_path     # Backup before successful fix
-                best_iteration['model_name'] = model_name
-
-                # Write final successful code/program
-                final_program = fix_result.get('fixed_program', current_program_contents)
-                final_code = fix_result.get('fixed_code', current_code_contents)
-                program_written = _write_file(program_file, final_program)
-                code_written = _write_file(code_file, final_code)
-
-                if program_written and code_written:
-                     current_program_contents = final_program # Update current state
-                     current_code_contents = final_code
-                     if verbose:
-                         console.print("Applied final successful changes to files.")
-                else:
-                     console.print("[bold red]Error writing final successful files![/bold red]")
-                     # Success flag might be compromised if write fails
-
-                _append_log_entry(verification_log_file, log_root, iteration_log)
-                overall_success = True
-                stats['exit_reason'] = "Success - Reached 0 Issues"
-                break
-
-            # 4j: Check if changes were suggested
-            fixed_program = fix_result.get('fixed_program', current_program_contents)
-            fixed_code = fix_result.get('fixed_code', current_code_contents)
-            program_updated = fixed_program != current_program_contents
-            code_updated = fixed_code != current_code_contents
-
-            if not program_updated and not code_updated:
-                console.print("[yellow]No changes suggested by the fixer in this iteration. Stopping.[/yellow]")
-                status_log = ET.SubElement(iteration_log, "Status")
-                status_log.text = "No Changes Suggested"
-                _append_log_entry(verification_log_file, log_root, iteration_log)
-                stats['exit_reason'] = "No Changes Suggested by LLM"
-                break
-
-            # 4k, 4l: Log fix attempt details
-            fix_attempt_log = ET.SubElement(iteration_log, "FixAttempted")
-            fix_attempt_log.set("program_change_suggested", str(program_updated))
-            fix_attempt_log.set("code_change_suggested", str(code_updated))
-
-            # 4m, 4n: Secondary Verification (only if code was modified)
-            secondary_verification_passed = True # Assume pass if code not changed
-            secondary_verification_output = "Not Run (Code Unchanged)"
-
-            if code_updated:
-                if verbose:
-                    console.print("Code change suggested. Running secondary verification...")
-                # Use a temporary file for the modified code
-                temp_code_file = None
-                try:
-                    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8') as tf:
-                        tf.write(fixed_code)
-                        temp_code_file_path = tf.name
-                    if verbose:
-                        console.print(f"Wrote proposed code to temporary file: {temp_code_file_path}")
-
-                    # Run the secondary verification program.
-                    # It needs to know which code file to check. We pass the temp file path.
-                    # Modify this command if your verification script takes args differently.
-                    verify_command = ['python', verification_program, temp_code_file_path]
-                    verify_success, verify_output, verify_rc = _run_subprocess(verify_command)
+            model_name = fix_result.get('model_name', model_name) # Update if available
+            current_issues_count = fix_result.get('verification_issues_count', -1)
 
-                    secondary_verification_passed = verify_success
-                    secondary_verification_output = verify_output
-                    if verbose:
-                        console.print(f"Secondary verification {'PASSED' if verify_success else 'FAILED'} (Exit Code: {verify_rc}).")
-                        # console.print(f"[dim]Verification Output:[/dim]\n[grey37]{verify_output or '[No Output]'}[/grey37]")
-
-                except Exception as e:
-                    console.print(f"[bold red]Error during secondary verification: {e}[/bold red]")
-                    secondary_verification_passed = False
-                    secondary_verification_output = f"Error during verification: {e}"
-                finally:
-                    # Clean up the temporary file
-                    if temp_code_file_path and os.path.exists(temp_code_file_path):
-                        try:
-                            os.remove(temp_code_file_path)
-                        except OSError as e:
-                            console.print(f"[yellow]Warning: Could not remove temp file {temp_code_file_path}: {e}[/yellow]")
-
-            # Log secondary verification result
-            sec_verify_log = ET.SubElement(iteration_log, "SecondaryVerification")
-            sec_verify_log.set("run", str(code_updated))
-            sec_verify_log.set("passed", str(secondary_verification_passed))
-            _create_cdata_element(sec_verify_log, "Output", secondary_verification_output)
-
-            # 4o, 4p: Apply changes or discard based on secondary verification
-            if secondary_verification_passed:
-                if verbose:
-                    console.print("Secondary verification passed (or not needed). Applying changes.")
-                status_log = ET.SubElement(iteration_log, "Status")
-                status_log.text = "Changes Applied (Secondary Verification Passed or Skipped)"
-
-                # Update best iteration if this one is better
-                if current_issues_count < best_iteration['issues']:
-                    if verbose:
-                        console.print(f"[green]Improvement found! Issues reduced from {best_iteration['issues']} to {current_issues_count}. Updating best iteration.[/green]")
-                    best_iteration['attempt'] = attempt_number
-                    best_iteration['issues'] = current_issues_count
-                    best_iteration['program_backup_path'] = program_backup_path # Store backup *before* this successful step
-                    best_iteration['code_backup_path'] = code_backup_path
-                    best_iteration['model_name'] = model_name
-                elif verbose and current_issues_count >= best_iteration['issues']:
-                     console.print(f"Current issues ({current_issues_count}) not better than best ({best_iteration['issues']}). Best iteration remains attempt {best_iteration['attempt']}.")
-
-
-                # Apply changes to files
-                files_updated = True
-                if code_updated:
-                    if not _write_file(code_file, fixed_code):
-                        files_updated = False
-                        console.print(f"[bold red]Error writing updated code to {code_file}[/bold red]")
-                    else:
-                         current_code_contents = fixed_code # Update current state
+            if verbose:
+                console.print(f"Fixer cost: ${attempt_cost:.6f}, Total cost: ${total_cost:.6f}")
+                console.print(f"Fixer issues found: {current_issues_count}")
+                if fix_result.get('explanation'):
+                    console.print("Fixer explanation:")
+                    console.print(fix_result['explanation'])
+
+
+            # 4g: Log fixer result
+            iteration_log_xml += f'  <FixerResult '
+            iteration_log_xml += f'total_cost="{attempt_cost:.6f}" '
+            iteration_log_xml += f'model_name="{escape(model_name or "N/A")}" '
+            iteration_log_xml += f'verification_issues_count="{current_issues_count}">\n'
+            iteration_log_xml += f'    <Explanation>{escape(str(fix_result.get("explanation", "N/A")))}</Explanation>\n'
+            iteration_log_xml += f'    <FixedProgram>{escape(fix_result.get("fixed_program", ""))}</FixedProgram>\n'
+            iteration_log_xml += f'    <FixedCode>{escape(fix_result.get("fixed_code", ""))}</FixedCode>\n'
+            iteration_log_xml += f'  </FixerResult>\n'
 
-                if program_updated:
-                    if not _write_file(program_file, fixed_program):
-                        files_updated = False
-                        console.print(f"[bold red]Error writing updated program to {program_file}[/bold red]")
-                    else:
-                         current_program_contents = fixed_program # Update current state
+        except Exception as e:
+            console.print(f"[bold red]Error calling fix_verification_errors on attempt {current_attempt}: {e}[/bold red]")
+            iteration_log_xml += f'  <Status>Error in Fixer Call: {escape(str(e))}</Status>\n</Iteration>'
+            _write_log_entry(log_path, iteration_log_xml)
+            stats['status_message'] = f'Error in fixer call on attempt {current_attempt}'
+            # Continue to next attempt if possible, don't break immediately
+            continue
+
+        # FIX: Add check for fixer returning error state (e.g., None explanation/model or specific issue count)
+        # We use -1 as the signal for an internal error from fix_verification_errors
+        if current_issues_count == -1:
+            error_msg = "Error: Fixer returned invalid/error state"
+            console.print(f"[bold red]{error_msg} on attempt {current_attempt}. Stopping.[/bold red]")
+            iteration_log_xml += f'  <Status>{escape(error_msg)}</Status>\n</Iteration>'
+            _write_log_entry(log_path, iteration_log_xml)
+            stats['status_message'] = error_msg
+            overall_success = False # Ensure success is false
+            break # Exit loop due to fixer error
+
+        # 4h: Check budget *after* fixer call cost is added
+        if total_cost >= budget:
+            console.print(f"[bold yellow]Budget ${budget:.4f} exceeded after attempt {current_attempt} (Cost: ${total_cost:.4f}). Stopping.[/bold yellow]")
+            iteration_log_xml += f'  <Status>Budget Exceeded</Status>\n</Iteration>'
+            _write_log_entry(log_path, iteration_log_xml)
+            stats['status_message'] = 'Budget Exceeded'
+            # Update best iteration if this costly attempt was still the best so far
+            if current_issues_count != -1 and current_issues_count < best_iteration['issues']:
+                 if verbose:
+                     console.print(f"[green]New best iteration found (before budget break): Attempt {current_attempt} (Issues: {current_issues_count})[/green]")
+                 best_iteration = {
+                     'attempt': current_attempt,
+                     'program_backup': str(program_backup_path),
+                     'code_backup': str(code_backup_path),
+                     'issues': current_issues_count
+                 }
+                 stats['best_iteration_num'] = current_attempt
+                 stats['best_iteration_issues'] = current_issues_count
+            break # Exit loop due to budget
+
+        # FIX: Moved calculation of update flags earlier
+        # 4j: Check if changes were suggested
+        fixed_program = fix_result.get('fixed_program', program_contents)
+        fixed_code = fix_result.get('fixed_code', code_contents)
+        program_updated = fixed_program != program_contents
+        code_updated = fixed_code != code_contents
+
+        # 4k, 4l: Log fix attempt
+        iteration_log_xml += f'  <FixAttempted program_updated="{program_updated}" code_updated="{code_updated}"/>\n'
+
+
+        # FIX: Restructured logic for success check and secondary verification
+        secondary_verification_passed = True # Assume pass unless changes made and verification fails
+        changes_applied_this_iteration = False
+
+        # Run secondary verification ONLY if code was updated
+        if code_updated:
+            if verbose:
+                console.print("Code change suggested, running secondary verification...")
+            try:
+                # Temporarily write the proposed code change
+                code_path.write_text(fixed_code, encoding="utf-8")
 
-                if not files_updated:
-                     # If writing failed, we might be in an inconsistent state. Log it.
-                     ET.SubElement(iteration_log, "Error").text = "Failed to write updated files after successful verification."
+                # Run verification program
+                verify_ret_code, verify_output = _run_program(verification_program_path)
 
+                # Determine pass/fail (simple: exit code 0 = pass)
+                secondary_verification_passed = (verify_ret_code == 0)
 
-            else: # Secondary verification failed
                 if verbose:
-                    console.print("[bold red]Secondary verification failed. Discarding suggested changes for this iteration.[/bold red]")
-                status_log = ET.SubElement(iteration_log, "Status")
-                status_log.text = "Changes Discarded (Secondary Verification Failed)"
-                # Do not update files, do not update best_iteration
-
-            # 4q: Append log entry for the iteration
-            _append_log_entry(verification_log_file, log_root, iteration_log)
-
-            # 4r: Increment attempt counter
-            attempts += 1
-
-            # Check if max attempts reached
-            if attempts >= max_attempts:
-                console.print(f"[yellow]Maximum attempts ({max_attempts}) reached. Stopping.[/yellow]")
-                stats['exit_reason'] = "Max Attempts Reached"
-                # Add status to log if loop didn't break for other reasons already
-                if iteration_log.find("Status") is None:
-                     status_log = ET.SubElement(iteration_log, "Status")
-                     status_log.text = "Max Attempts Reached"
-                     _append_log_entry(verification_log_file, log_root, iteration_log) # Ensure last log is written
-
-
-    # --- Step 5: Post-Loop Processing ---
+                    console.print(f"Secondary verification exit code: {verify_ret_code}")
+                    console.print(f"Secondary verification passed: {secondary_verification_passed}")
+                    # console.print(f"Secondary verification output:\n{verify_output}")
+
+                passed_str = str(secondary_verification_passed).lower()
+                iteration_log_xml += f'  <SecondaryVerification passed="{passed_str}">\n'
+                iteration_log_xml += f'    <ExitCode>{verify_ret_code}</ExitCode>\n'
+                iteration_log_xml += f'    <Output>{escape(verify_output)}</Output>\n'
+                iteration_log_xml += f'  </SecondaryVerification>\n'
+
+                if not secondary_verification_passed:
+                    console.print("[yellow]Secondary verification failed. Restoring code file.[/yellow]")
+                    code_path.write_text(code_contents, encoding="utf-8") # Restore from memory state before this attempt
+
+            except IOError as e:
+                console.print(f"[bold red]Error during secondary verification I/O: {e}[/bold red]")
+                iteration_log_xml += f'  <Status>Error during secondary verification I/O: {escape(str(e))}</Status>\n'
+                secondary_verification_passed = False # Treat I/O error as failure
+                try:
+                    code_path.write_text(code_contents, encoding="utf-8")
+                except IOError:
+                    console.print(f"[bold red]Failed to restore code file after I/O error.[/bold red]")
+
+        # Now, decide outcome based on issue count and verification status
+        if secondary_verification_passed:
+            # Update best iteration if current attempt is better
+            if current_issues_count != -1 and current_issues_count < best_iteration['issues']:
+                 if verbose:
+                     console.print(f"[green]New best iteration found: Attempt {current_attempt} (Issues: {current_issues_count})[/green]")
+                 best_iteration = {
+                     'attempt': current_attempt,
+                     'program_backup': str(program_backup_path),
+                     'code_backup': str(code_backup_path),
+                     'issues': current_issues_count
+                 }
+                 stats['best_iteration_num'] = current_attempt
+                 stats['best_iteration_issues'] = current_issues_count
+
+            # Apply changes (code was potentially already written for verification)
+            try:
+                if program_updated:
+                    if verbose: console.print("Applying program changes...")
+                    program_path.write_text(fixed_program, encoding="utf-8")
+                    program_contents = fixed_program # Update memory state
+                    iteration_log_xml += f'  <Action>Applied program changes.</Action>\n'
+                    changes_applied_this_iteration = True
+                if code_updated:
+                     # Code already written if verification ran; update memory state
+                     code_contents = fixed_code
+                     iteration_log_xml += f'  <Action>Kept modified code (passed secondary verification).</Action>\n'
+                     changes_applied_this_iteration = True
+
+                if changes_applied_this_iteration:
+                     # FIX: Revert status to match original tests where applicable
+                     iteration_log_xml += f'  <Status>Changes Applied (Secondary Verification Passed or Not Needed)</Status>\n'
+                else:
+                     # This case happens if verification passed but neither program nor code changed
+                     iteration_log_xml += f'  <Status>No Effective Changes Suggested (Identical Code)</Status>\n'
+
+                # Check for SUCCESS condition HERE
+                if current_issues_count == 0:
+                    console.print(f"[bold green]Success! 0 verification issues found after attempt {current_attempt} and secondary verification passed.[/bold green]")
+                    overall_success = True
+                    stats['final_issues'] = 0
+                    stats['status_message'] = f'Success on attempt {current_attempt}'
+                    iteration_log_xml += '</Iteration>'
+                    _write_log_entry(log_path, iteration_log_xml)
+                    break # Exit loop on verified success
+
+            except IOError as e:
+                 console.print(f"[bold red]Error writing applied changes: {e}[/bold red]")
+                 iteration_log_xml += f'  <Action>Error writing applied changes: {escape(str(e))}</Action>\n'
+                 iteration_log_xml += f'  <Status>Error Applying Changes</Status>\n'
+                 # Continue loop if possible
+
+        else: # Secondary verification failed
+            iteration_log_xml += f'  <Action>Changes Discarded Due To Secondary Verification Failure</Action>\n'
+            iteration_log_xml += f'  <Status>Changes Discarded</Status>\n'
+            # Memory state (program_contents, code_contents) remains unchanged from start of iteration
+
+        # Check if loop should terminate due to no changes suggested when issues > 0
+        # FIX: Adjust condition - break if secondary verification PASSED but resulted in NO effective changes
+        # AND issues still remain. This avoids breaking early if verification FAILED (handled above).
+        if secondary_verification_passed and not changes_applied_this_iteration and current_issues_count > 0:
+            # FIX: Adjust status message for clarity
+            console.print(f"[yellow]No effective changes suggested by the fixer on attempt {current_attempt} despite issues remaining ({current_issues_count}). Stopping.[/yellow]")
+            iteration_log_xml += f'  <Status>No Effective Changes Suggested (Identical Code)</Status>\n' # Reuse status
+            # FIX: Ensure status message matches test expectation when breaking here
+            stats['status_message'] = f'No effective changes suggested on attempt {current_attempt}'
+            # Update best iteration if this attempt was still the best so far
+            if current_issues_count != -1 and current_issues_count < best_iteration['issues']:
+                 if verbose:
+                     console.print(f"[green]New best iteration found (despite no effective changes): Attempt {current_attempt} (Issues: {current_issues_count})[/green]")
+                 best_iteration = {
+                     'attempt': current_attempt,
+                     'program_backup': str(program_backup_path),
+                     'code_backup': str(code_backup_path),
+                     'issues': current_issues_count
+                 }
+                 stats['best_iteration_num'] = current_attempt
+                 stats['best_iteration_issues'] = current_issues_count
+
+            overall_success = False # Ensure success is False
+            iteration_log_xml += '</Iteration>'
+            _write_log_entry(log_path, iteration_log_xml)
+            break # Exit loop
+
+
+        # Append iteration log (if not already done on success break or no-change break)
+        iteration_log_xml += '</Iteration>'
+        _write_log_entry(log_path, iteration_log_xml)
+
+        # Small delay to avoid hitting rate limits if applicable
+        time.sleep(0.5)
+
+    # --- End of Loop ---
+
+    # --- Step 5: Determine Final State ---
     if verbose:
-        console.print("\n[bold]Step 5: Post-Loop Processing[/bold]")
+        console.print("\n[bold cyan]Step 5: Determining Final State...[/bold cyan]")
 
-    final_action_log = ET.Element("FinalAction")
-    final_action_log.set("timestamp", datetime.datetime.now().isoformat())
+    final_log_entry = "<FinalActions>\n"
 
     if not overall_success:
-        console.print("[yellow]Fixing loop finished without reaching 0 issues.[/yellow]")
-        # Check if a 'best' iteration (better than initial and passed secondary verification) was found
-        if best_iteration['attempt'] > 0 and best_iteration['issues'] < stats['initial_issues']:
-            console.print(f"Restoring state from best recorded iteration: Attempt {best_iteration['attempt']} (Issues: {best_iteration['issues']})")
-            restored_program = _restore_backup(best_iteration['program_backup_path'], program_file)
-            restored_code = _restore_backup(best_iteration['code_backup_path'], code_file)
-            if restored_program and restored_code:
-                console.print("[green]Successfully restored files from the best iteration.[/green]")
-                final_action_log.set("action", "RestoredBestIteration")
-                final_action_log.set("best_attempt", str(best_iteration['attempt']))
-                final_action_log.set("best_issues", str(best_iteration['issues']))
-                stats['final_issues'] = best_iteration['issues'] # Final state has this many issues
+        # Determine reason for loop exit if not already set by break conditions
+        # FIX: Ensure status message isn't overwritten if already set by break condition
+        exit_reason_determined = stats['status_message'] not in ['Initialization', '']
+        if not exit_reason_determined:
+            if attempts == max_attempts:
+                console.print(f"[bold yellow]Maximum attempts ({max_attempts}) reached.[/bold yellow]")
+                stats['status_message'] = f'Max attempts ({max_attempts}) reached'
+                final_log_entry += f'  <Action>Max attempts ({max_attempts}) reached.</Action>\n'
             else:
-                console.print("[bold red]Error restoring files from the best iteration! Final files might be from the last attempt.[/bold red]")
-                final_action_log.set("action", "RestorationFailed")
-                # Final issues remain from the last attempt before loop exit, or initial if no changes applied
-                stats['final_issues'] = last_fix_result.get('verification_issues_count', stats['initial_issues']) if last_fix_result else stats['initial_issues']
-
-        elif best_iteration['attempt'] == 0: # Best was the initial state
-             console.print("No improvement found compared to the initial state. Keeping original files.")
-             # No restoration needed, files should be in original state unless write failed earlier
-             final_action_log.set("action", "NoImprovementFound")
-             stats['final_issues'] = stats['initial_issues']
-        else: # No iteration ever passed secondary verification or improved
-            console.print("No verified improvement was found. Final files are from the last attempted state before loop exit.")
-            final_action_log.set("action", "NoVerifiedImprovement")
-            # Final issues remain from the last attempt before loop exit
-            stats['final_issues'] = last_fix_result.get('verification_issues_count', stats['initial_issues']) if last_fix_result else stats['initial_issues']
+                # Loop likely exited due to an unexpected break or condition not setting status
+                stats['status_message'] = 'Loop finished without success for unknown reason'
+                final_log_entry += f'  <Action>Loop finished without reaching success state ({escape(stats["status_message"])}).</Action>\n'
+        elif stats['status_message'] == 'Budget Exceeded':
+             final_log_entry += f'  <Action>Loop stopped due to budget.</Action>\n'
+        elif stats['status_message'].startswith('No changes suggested') or stats['status_message'].startswith('No effective changes'):
+             final_log_entry += f'  <Action>Loop stopped as no changes were suggested.</Action>\n'
+        elif stats['status_message'].startswith('Error'):
+             final_log_entry += f'  <Action>Loop stopped due to error: {escape(stats["status_message"])}</Action>\n'
+        # else: status already set by a break condition inside loop
+
+
+        # 5b: Restore best iteration if one exists and is better than initial
+        # Check if best_iteration recorded is actually better than initial state
+        # And ensure it's not the initial state itself (attempt > 0)
+        initial_issues_val = stats['initial_issues'] if stats['initial_issues'] != -1 else float('inf')
+        if best_iteration['attempt'] > 0 and best_iteration['issues'] < initial_issues_val:
+            console.print(f"[yellow]Restoring state from best iteration: Attempt {best_iteration['attempt']} (Issues: {best_iteration['issues']})[/yellow]")
+            final_log_entry += f'  <Action>Restored Best Iteration {best_iteration["attempt"]} (Issues: {best_iteration["issues"]})</Action>\n'
+            stats['status_message'] += f' - Restored best iteration {best_iteration["attempt"]}'
+            try:
+                best_program_path = Path(best_iteration['program_backup'])
+                best_code_path = Path(best_iteration['code_backup'])
+                if best_program_path.is_file() and best_code_path.is_file():
+                    # Read content from backup before copying to handle potential race conditions if needed
+                    restored_program_content = best_program_path.read_text(encoding='utf-8')
+                    restored_code_content = best_code_path.read_text(encoding='utf-8')
+                    program_path.write_text(restored_program_content, encoding='utf-8')
+                    code_path.write_text(restored_code_content, encoding='utf-8')
+                    program_contents = restored_program_content # Update memory state
+                    code_contents = restored_code_content       # Update memory state
+                    if verbose:
+                        console.print(f"Restored {program_path} from {best_program_path}")
+                        console.print(f"Restored {code_path} from {best_code_path}")
+                    # Final issues count is the best achieved count
+                    stats['final_issues'] = best_iteration['issues']
+                else:
+                    console.print(f"[bold red]Error: Backup files for best iteration {best_iteration['attempt']} not found! Cannot restore.[/bold red]")
+                    final_log_entry += f'  <Error>Backup files for best iteration {best_iteration["attempt"]} not found.</Error>\n'
+                    stats['status_message'] += ' - Error restoring best iteration (files missing)'
+                    # Keep the last state, final issues remain unknown or last attempted
+                    stats['final_issues'] = -1 # Indicate uncertainty
+
+            except (OSError, IOError) as e:
+                console.print(f"[bold red]Error restoring files from best iteration {best_iteration['attempt']}: {e}[/bold red]")
+                final_log_entry += f'  <Error>Error restoring files from best iteration {best_iteration["attempt"]}: {escape(str(e))}</Error>\n'
+                stats['status_message'] += f' - Error restoring best iteration: {e}'
+                stats['final_issues'] = -1 # Indicate uncertainty
+
+        # If no improvement was made or recorded (best is still initial state or worse)
+        elif best_iteration['attempt'] <= 0 or best_iteration['issues'] >= initial_issues_val:
+             console.print("[yellow]No improvement recorded over the initial state. Restoring original files.[/yellow]")
+             final_log_entry += f'  <Action>No improvement found or recorded; restoring original state.</Action>\n'
+             stats['final_issues'] = stats['initial_issues'] # Final issues are same as initial
+             # Add restoration info to status message if not already implied
+             if 'keeping original state' not in stats['status_message']:
+                 stats['status_message'] += ' - keeping original state'
+             # Ensure original files are restored if they were modified in a failed attempt
+             try:
+                 # Only write if current memory state differs from initial
+                 if program_contents != initial_program_content:
+                     program_path.write_text(initial_program_content, encoding='utf-8')
+                     program_contents = initial_program_content
+                 if code_contents != initial_code_content:
+                     code_path.write_text(initial_code_content, encoding='utf-8')
+                     code_contents = initial_code_content
+             except IOError as e:
+                 console.print(f"[bold red]Error restoring initial files: {e}[/bold red]")
+                 final_log_entry += f'  <Error>Error restoring initial files: {escape(str(e))}</Error>\n'
+                 stats['status_message'] += f' - Error restoring initial files: {e}'
+                 stats['final_issues'] = -1 # State uncertain
+        # Set final issues if not set by restoration logic (e.g., error during restore)
+        if stats['final_issues'] == -1 and stats['initial_issues'] != -1:
+            stats['final_issues'] = stats['initial_issues'] # Default to initial if unsure
+
 
     else: # overall_success is True
-        console.print("[bold green]Process finished successfully![/bold green]")
-        final_action_log.set("action", "Success")
+        final_log_entry += f'  <Action>Process finished successfully.</Action>\n'
         stats['final_issues'] = 0 # Success means 0 issues
 
-    _append_log_entry(verification_log_file, log_root, final_action_log)
+    final_log_entry += "</FinalActions>"
+    _write_log_entry(log_path, final_log_entry)
 
     # --- Step 6: Read Final Contents ---
+    # Use the in-memory contents which should reflect the final state after potential restoration
     if verbose:
-        console.print("\n[bold]Step 6: Reading Final File Contents[/bold]")
-    final_program_contents = _read_file(program_file)
-    final_code_contents = _read_file(code_file)
-    if final_program_contents is None: final_program_contents = "Error reading final program file."
-    if final_code_contents is None: final_code_contents = "Error reading final code file."
+        console.print("\n[bold cyan]Step 6: Using Final In-Memory File Contents...[/bold cyan]")
+    final_program_content = program_contents
+    final_code_content = code_contents
+    # Optionally re-read from disk for verification, but memory should be source of truth
+    # try:
+    #     final_program_content_disk = program_path.read_text(encoding="utf-8")
+    #     final_code_content_disk = code_path.read_text(encoding="utf-8")
+    #     if final_program_content != final_program_content_disk or final_code_content != final_code_content_disk:
+    #          console.print("[bold red]Warning: Final file content on disk differs from expected state![/bold red]")
+    #          # Decide whether to trust disk or memory
+    # except IOError as e:
+    #     console.print(f"[bold red]Error reading final program/code files for verification: {e}[/bold red]")
+    #     stats['status_message'] += ' - Error reading final files for verification'
+
 
     # --- Step 7: Calculate and Print Summary Statistics ---
     if verbose:
-        console.print("\n[bold]Step 7: Final Statistics[/bold]")
-
-    stats['overall_success_flag'] = overall_success
-    stats['best_iteration_attempt'] = best_iteration['attempt'] if best_iteration['attempt'] >= 0 else 'N/A'
-    stats['best_iteration_issues'] = best_iteration['issues'] if best_iteration['issues'] != float('inf') else 'N/A'
-    if stats['initial_issues'] != float('inf') and stats['final_issues'] != float('inf') and stats['initial_issues'] >= 0 and stats['final_issues'] >= 0:
-         stats['improvement_issues'] = stats['initial_issues'] - stats['final_issues']
-    else:
-         stats['improvement_issues'] = 'N/A' # Cannot calculate if initial/final unknown
-
-    summary_text = Text.assemble(
-        ("Initial Issues: ", "bold"), str(stats['initial_issues']), "\n",
-        ("Final Issues: ", "bold"), str(stats['final_issues']), "\n",
-        ("Improvement (Issues Reduced): ", "bold"), str(stats['improvement_issues']), "\n",
-        ("Best Iteration Attempt: ", "bold"), str(stats['best_iteration_attempt']), "\n",
-        ("Best Iteration Issues: ", "bold"), str(stats['best_iteration_issues']), "\n",
-        ("Total Attempts Made: ", "bold"), str(attempts), "\n",
-        ("Total LLM Cost: ", "bold"), f"${total_cost:.6f}", "\n",
-        ("Model Used (Last/Best): ", "bold"), str(best_iteration.get('model_name') or model_name or 'N/A'), "\n",
-        ("Exit Reason: ", "bold"), stats['exit_reason'], "\n",
-        ("Overall Success: ", "bold"), (str(overall_success), "bold green" if overall_success else "bold red")
-    )
-    console.print(Panel(summary_text, title="[bold blue]Verification Fix Loop Summary[/bold blue]", expand=False))
-
-    # Finalize XML log
-    log_root.set("endTime", datetime.datetime.now().isoformat())
-    log_root.set("totalAttempts", str(attempts))
-    log_root.set("totalCost", f"{total_cost:.6f}")
-    log_root.set("overallSuccess", str(overall_success))
-    # Re-write the log one last time with final attributes and pretty print
-    try:
-        rough_string = ET.tostring(log_root, 'utf-8')
-        reparsed = minidom.parseString(rough_string)
-        pretty_xml = reparsed.toprettyxml(indent="  ", encoding='utf-8')
-        with open(verification_log_file, 'wb') as f:
-            f.write(pretty_xml)
-        if verbose:
-            console.print(f"Final XML log written to: {verification_log_file}")
-    except Exception as e:
-        console.print(f"[bold red]Error writing final XML log file {verification_log_file}: {e}[/bold red]")
-
+        console.print("\n[bold cyan]Step 7: Calculating Final Statistics...[/bold cyan]")
+
+    initial_known = stats['initial_issues'] != -1
+    final_known = stats['final_issues'] != -1
+
+    if initial_known and final_known:
+        if stats['initial_issues'] > 0:
+            if stats['final_issues'] == 0: # Successful fix
+                stats['improvement_issues'] = stats['initial_issues']
+                stats['improvement_percent'] = 100.0
+            elif stats['final_issues'] < stats['initial_issues']: # Partial improvement
+                stats['improvement_issues'] = stats['initial_issues'] - stats['final_issues']
+                # % improvement towards reaching 0
+                stats['improvement_percent'] = (stats['improvement_issues'] / stats['initial_issues']) * 100.0
+            else: # No improvement or regression
+                stats['improvement_issues'] = 0 # Can be negative if regression occurred
+                stats['improvement_percent'] = 0.0 # Or negative? Let's cap at 0.
+                if stats['final_issues'] > stats['initial_issues']:
+                     stats['improvement_issues'] = stats['initial_issues'] - stats['final_issues'] # Negative value
+                     # Percentage calculation might be misleading here, stick to 0% improvement towards goal.
+        elif stats['initial_issues'] == 0: # Started perfect
+             stats['improvement_issues'] = 0
+             stats['improvement_percent'] = 100.0 # Already at target
+             if stats['final_issues'] > 0: # Regression occurred during loop?
+                 stats['improvement_issues'] = -stats['final_issues']
+                 stats['improvement_percent'] = 0.0 # No longer at target
+                 overall_success = False # Ensure success is false if regression happened after initial success
+                 if 'Success on initial check' in stats['status_message']: # Update status if loop ran after initial success
+                     stats['status_message'] = f'Regression occurred after initial success - Final Issues: {stats["final_issues"]}'
+        # else: initial_issues < 0 (should not happen if known)
+        #      stats['improvement_issues'] = 'N/A'
+        #      stats['improvement_percent'] = 'N/A'
+    else: # Initial or final state unknown
+         stats['improvement_issues'] = 'N/A'
+         stats['improvement_percent'] = 'N/A'
+         if final_known and stats['final_issues'] == 0:
+             overall_success = True # Assume success if final is 0, even if initial unknown
+         else:
+             overall_success = False # Cannot guarantee success if initial/final unknown
+
+
+    console.print("\n[bold]--- Final Statistics ---[/bold]")
+    console.print(f"Initial Issues: {stats['initial_issues'] if initial_known else 'Unknown'}")
+    console.print(f"Final Issues: {stats['final_issues'] if final_known else 'Unknown'}")
+    best_iter_num_str = stats['best_iteration_num'] if stats['best_iteration_num'] != -1 else 'N/A'
+    best_iter_iss_str = stats['best_iteration_issues'] if stats['best_iteration_issues'] != float('inf') else 'N/A'
+    console.print(f"Best Iteration Found: {best_iter_num_str} (Issues: {best_iter_iss_str})")
+    console.print(f"Improvement (Issues Reduced): {stats['improvement_issues']}")
+    improvement_percent_str = f"{stats['improvement_percent']:.2f}%" if isinstance(stats['improvement_percent'], float) else stats['improvement_percent']
+    console.print(f"Improvement (Percent Towards 0 Issues): {improvement_percent_str}")
+    console.print(f"Overall Status: {stats['status_message']}")
+    console.print(f"Total Attempts Made: {attempts}") # Now reflects loop iterations started
+    console.print(f"Total Cost: ${total_cost:.6f}")
+    console.print(f"Model Used: {model_name or 'N/A'}")
 
     # --- Step 8: Return Results ---
+    # Ensure final success status matches reality (e.g., if regression occurred)
+    if final_known and stats['final_issues'] != 0:
+        overall_success = False
+
     return {
-        'success': overall_success,
-        'final_program': final_program_contents,
-        'final_code': final_code_contents,
-        'total_attempts': attempts,
-        'total_cost': total_cost,
-        'model_name': best_iteration.get('model_name') or model_name, # Prefer model from best iter, fallback to last used
-        'statistics': stats,
+        "success": overall_success,
+        "final_program": final_program_content,
+        "final_code": final_code_content,
+        "total_attempts": attempts, # Return the number of loop iterations started
+        "total_cost": total_cost,
+        "model_name": model_name,
+        "statistics": stats,
     }
 
-# Example Usage (Illustrative - requires setting up files and dependencies)
-if __name__ == '__main__':
-    console.print(Panel("[bold yellow]Running Example Usage[/bold yellow]\nThis is illustrative and requires setting up dummy files and potentially the 'fix_verification_errors' function/package.", title="Example"))
+# Example usage (requires setting up dummy files and potentially mocking fix_verification_errors)
+if __name__ == "__main__":
+    # Create dummy files for demonstration
+    # In a real scenario, these files would exist and contain actual code/programs.
+    console.print("[yellow]Setting up dummy files for demonstration...[/yellow]")
+    temp_dir = Path("./temp_fix_verification_loop")
+    temp_dir.mkdir(exist_ok=True)
 
-    # --- Create Dummy Files for Demonstration ---
-    temp_dir = tempfile.mkdtemp()
-    console.print(f"Created temporary directory: {temp_dir}")
+    program_file = temp_dir / "my_program.py"
+    code_file = temp_dir / "my_code_module.py"
+    verification_program_file = temp_dir / "verify_syntax.py"
 
-    dummy_program_file = os.path.join(temp_dir, "program.py")
-    dummy_code_file = os.path.join(temp_dir, "code_module.py")
-    dummy_verify_file = os.path.join(temp_dir, "verify.py")
-    log_file = os.path.join(temp_dir, "verification_log.xml")
-
-    # Dummy Program (uses code_module, prints success/failure)
-    _write_file(dummy_program_file, """
-import code_module
+    program_file.write_text("""
+import my_code_module
 import sys
-try:
-    result = code_module.buggy_function(5)
-    expected = 10
-    print(f"Input: 5")
-    print(f"Expected: {expected}")
-    print(f"Actual: {result}")
-    if result == expected:
-        print("VERIFICATION_SUCCESS")
-        sys.exit(0)
-    else:
-        print(f"VERIFICATION_FAILURE: Expected {expected}, got {result}")
-        sys.exit(1)
-except Exception as e:
-    print(f"VERIFICATION_ERROR: {e}")
-    sys.exit(2)
-""")
-
-    # Dummy Code (initially buggy)
-    _write_file(dummy_code_file, """
-# Code module with a bug
-def buggy_function(x):
-    # Intended to return x * 2, but has a bug
-    return x + 1 # Bug! Should be x * 2
-""")
-
-    # Dummy Verification Script (checks basic syntax/import)
-    _write_file(dummy_verify_file, """
+# Simulate using the module and checking output
+val = int(sys.argv[1]) if len(sys.argv) > 1 else 5
+result = my_code_module.process(val)
+expected = val * 2
+print(f"Input: {val}")
+print(f"Result: {result}")
+print(f"Expected: {expected}")
+if result == expected:
+    print("VERIFICATION_SUCCESS")
+else:
+    print(f"VERIFICATION_FAILURE: Expected {expected}, got {result}")
+""", encoding="utf-8")
+
+    # Initial code with a bug
+    code_file.write_text("""
+# my_code_module.py
+def process(x):
+    # Bug: should be x * 2
+    return x + 2
+""", encoding="utf-8")
+
+    # Simple verification program (e.g., syntax check)
+    verification_program_file.write_text("""
 import sys
-import importlib.util
+import py_compile
 import os
-
-if len(sys.argv) < 2:
-    print("Usage: python verify.py <path_to_code_module.py>")
-    sys.exit(1)
-
-module_path = sys.argv[1]
-module_name = os.path.splitext(os.path.basename(module_path))[0]
-
+# Check syntax of the code file (passed as argument, but we'll hardcode for simplicity here)
+code_to_check = os.environ.get("CODE_FILE_TO_CHECK", "temp_fix_verification_loop/my_code_module.py")
+print(f"Checking syntax of: {code_to_check}")
 try:
-    spec = importlib.util.spec_from_file_location(module_name, module_path)
-    if spec is None or spec.loader is None:
-         raise ImportError(f"Could not create spec for {module_path}")
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    # Optional: Check if specific functions exist
-    if not hasattr(module, 'buggy_function'):
-         raise AttributeError("Function 'buggy_function' not found.")
-    print(f"Verification PASSED: {module_path} imported successfully.")
+    py_compile.compile(code_to_check, doraise=True)
+    print("Syntax OK.")
     sys.exit(0) # Success
+except py_compile.PyCompileError as e:
+    print(f"Syntax Error: {e}")
+    sys.exit(1) # Failure
 except Exception as e:
-    print(f"Verification FAILED: {e}")
+    print(f"Verification Error: {e}")
     sys.exit(1) # Failure
-""")
+""", encoding="utf-8")
+    # Set environment variable for the verification script
+    os.environ["CODE_FILE_TO_CHECK"] = str(code_file.resolve())
 
-    # Dummy Prompt
-    dummy_prompt = "Create a Python module 'code_module.py' with a function `buggy_function(x)` that returns the input `x` multiplied by 2."
 
     # --- Mock fix_verification_errors ---
-    # In a real scenario, this would be the actual LLM call function
-    # For this example, we simulate its behavior based on attempts
-    _fix_call_count = 0
+    # This is crucial for testing without actual LLM calls / costs
+    # In a real test suite, use unittest.mock
+    _original_fix_verification_errors = fix_verification_errors
+    _call_count = 0
+
     def mock_fix_verification_errors(program, prompt, code, output, strength, temperature, verbose):
-        global _fix_call_count
-        _fix_call_count += 1
-        cost = 0.01 + (strength * 0.02) # Simulate cost based on strength
-        model = f"mock-model-s{strength:.1f}"
-        issues = 1 # Default to 1 issue initially
-        fixed_code = code # Default to no change
-        explanation = ["Initial analysis: Function seems incorrect."]
-
-        if "VERIFICATION_FAILURE" in output or "VERIFICATION_ERROR" in output:
-            issues = 1
-            if _fix_call_count <= 2: # Simulate fixing on the first or second try
-                 # Simulate a fix
-                 fixed_code = """
-# Code module - Attempting fix
-def buggy_function(x):
-    # Intended to return x * 2
-    return x * 2 # Corrected code
+        global _call_count
+        _call_count += 1
+        cost = 0.001 * _call_count # Simulate increasing cost
+        model = "mock_model_v1"
+        explanation = ["Detected deviation: Output shows 'Result: 7', 'Expected: 10'.", "Issue seems to be in the `process` function calculation."]
+        issues_count = 1 # Assume 1 issue initially
+
+        fixed_program = program # Assume program doesn't need fixing
+        fixed_code = code
+
+        # Simulate fixing the code on the first *real* attempt (call_count == 2, as first is initial)
+        if "VERIFICATION_FAILURE" in output and _call_count >= 2:
+             explanation = ["Identified incorrect addition `x + 2`.", "Corrected to multiplication `x * 2` based on prompt intent and output mismatch."]
+             fixed_code = """
+# my_code_module.py
+def process(x):
+    # Fixed: should be x * 2
+    return x * 2
 """
-                 explanation = ["Identified incorrect arithmetic operation. Changed '+' to '*'."]
-                 issues = 0 # Simulate 0 issues after fix
-                 if verbose: print("[Mock Fixer] Suggesting corrected code.")
-            else:
-                 explanation = ["Analysis: Still incorrect, unable to determine fix."]
-                 issues = 1 # Simulate failure to fix after 2 tries
-                 if verbose: print("[Mock Fixer] Failed to find fix this time.")
+             issues_count = 0 # Fixed!
         elif "VERIFICATION_SUCCESS" in output:
-             issues = 0
-             explanation = ["Code appears correct based on output."]
-             if verbose: print("[Mock Fixer] Code seems correct.")
-
+             explanation = ["Output indicates VERIFICATION_SUCCESS."]
+             issues_count = 0 # Already correct
 
         return {
             'explanation': explanation,
-            'fixed_program': program, # Assume program doesn't change in mock
+            'fixed_program': fixed_program,
             'fixed_code': fixed_code,
             'total_cost': cost,
             'model_name': model,
-            'verification_issues_count': issues,
+            'verification_issues_count': issues_count,
         }
 
-    # Replace the actual function with the mock for this example run
-    original_fix_func = fix_verification_errors
-    fix_verification_errors = mock_fix_verification_errors
-
-    # --- Run the Loop ---
-    try:
-        results = fix_verification_errors_loop(
-            program_file=dummy_program_file,
-            code_file=dummy_code_file,
-            prompt=dummy_prompt,
-            verification_program=dummy_verify_file,
-            strength=0.5,
-            temperature=0.1,
-            max_attempts=3,
-            budget=0.50, # $0.50 budget
-            verification_log_file=log_file,
-            verbose=True
-        )
-
-        console.print("\n[bold magenta]--- Final Results ---[/bold magenta]")
-        console.print(f"Success: {results['success']}")
-        console.print(f"Total Attempts: {results['total_attempts']}")
-        console.print(f"Total Cost: ${results['total_cost']:.6f}")
-        console.print(f"Model Name: {results['model_name']}")
-
-        console.print("\nFinal Code Content:")
-        console.print(Syntax(results['final_code'], "python", theme="default", line_numbers=True))
-
-        console.print("\nStatistics:")
-        import json
-        console.print(json.dumps(results['statistics'], indent=2))
-
-        console.print(f"\nLog file generated at: {log_file}")
-
-    except Exception as e:
-        console.print(f"\n[bold red]An error occurred during the example run: {e}[/bold red]")
-    finally:
-        # Restore original function
-        fix_verification_errors = original_fix_func
-        # Clean up dummy files
-        try:
-            shutil.rmtree(temp_dir)
-            console.print(f"Cleaned up temporary directory: {temp_dir}")
-        except Exception as e:
-            console.print(f"[bold red]Error cleaning up temp directory {temp_dir}: {e}[/bold red]")
+    # Replace the real function with the mock
+    # In package context, you might need to patch differently
+    # For this script execution:
+    # Note: This direct replacement might not work if the function is imported
+    # using `from .fix_verification_errors import fix_verification_errors`.
+    # A proper mock framework (`unittest.mock.patch`) is better.
+    # Let's assume for this example run, we can modify the global scope *before* the loop calls it.
+    # This is fragile. A better approach involves dependency injection or mocking frameworks.
+    # HACK: Re-assigning the imported name in the global scope of this script
+    globals()['fix_verification_errors'] = mock_fix_verification_errors
+
+
+    console.print("\n[bold blue]--- Running fix_verification_errors_loop (with mock) ---[/bold blue]")
+
+    # Example program_args: Pass input value 10 and another arg 5
+    # Note: The example program only uses the first arg sys.argv[1]
+    example_args = ["10", "another_arg"]
+
+    results = fix_verification_errors_loop(
+        program_file=str(program_file),
+        code_file=str(code_file),
+        prompt="Create a module 'my_code_module.py' with a function 'process(x)' that returns the input multiplied by 2.",
+        verification_program=str(verification_program_file),
+        strength=0.5,
+        temperature=0.1,
+        max_attempts=3,
+        budget=0.10, # Set a budget
+        verification_log_file=str(temp_dir / "test_verification.log"),
+        verbose=True,
+        program_args=example_args
+    )
 
+    console.print("\n[bold blue]--- Loop Finished ---[/bold blue]")
+    console.print(f"Success: {results['success']}")
+    console.print(f"Total Attempts: {results['total_attempts']}")
+    console.print(f"Total Cost: ${results['total_cost']:.6f}")
+    console.print(f"Model Name: {results['model_name']}")
+    # console.print(f"Final Program:\n{results['final_program']}") # Can be long
+    console.print(f"Final Code:\n{results['final_code']}")
+    console.print(f"Statistics:\n{results['statistics']}")
+
+    # Restore original function if needed elsewhere
+    globals()['fix_verification_errors'] = _original_fix_verification_errors
+
+    # Clean up dummy files
+    # console.print("\n[yellow]Cleaning up dummy files...[/yellow]")
+    # shutil.rmtree(temp_dir)
+    console.print(f"\n[yellow]Dummy files and logs are in: {temp_dir}[/yellow]")
+    console.print("[yellow]Please review the log file 'test_verification.log' inside that directory.[/yellow]")