Upload 11 files

Readme.md

@@ -0,0 +1,260 @@
+# Comprehensive LLM Evaluation Framework (ESI & Contextual ACC)
+
+## 1. Overview
+
+This framework provides a robust system for evaluating Large Language Models (LLMs) by generating responses to a given dataset and then assessing these responses across multiple dimensions. It uniquely features:
+
+* **Multi-Model & Multi-Prompt Testing**: Simultaneously evaluate various worker LLMs using different prompting strategies (e.g., Direct, Chain-of-Thought).
+* **Concurrent Pipelined Processing**: For each model-prompt combination, data items are processed through a concurrent pipeline (Worker LLM call -> Answer Cleaning -> Accuracy Judge call -> Integrity Judge call -> ESI Score calculation), maximizing efficiency for I/O-bound API calls.
+* **Context-Dependent Accuracy (ACC)**: Employs distinct judging criteria for accuracy based on the input dataset type (L1-1K, L2-1K, L3-1K), allowing for nuanced evaluation from very lenient to strict.
+* **True Integrity Score**: Assesses the completeness of the worker LLM's output and its thought process, specifically whether all conditions and aspects of the input were considered.
+* **ESI Score Calculation**: Computes an overall ESI (Efficiency, Safety, Integrity (True), Alignment (Simplified)) score, providing a multi-faceted view of model performance.
+* **Detailed Reporting**: Generates detailed JSONL output files for each test run and a JSON summary file with aggregated metrics.
+* **High Configurability**: All critical parameters, including API endpoints, tokens, model IDs, file paths, ESI weights, and evaluation criteria, are managed through a central `settings.json` file.
+
+This framework is designed to move beyond simple accuracy metrics and provide a more holistic understanding of LLM capabilities.
+
+## 2. Core Concepts & Definitions
+
+### 2.1. LLM Roles
+
+* **Worker LLM**: The primary LLM being evaluated. It generates answers based on the provided `instruction`, `question`, and a specific `prompt_version` (e.g., DIRECT, COT). Multiple Worker LLMs can be specified for comparative evaluation.
+* **Accuracy Judge LLM**: A separate LLM (e.g., `deepseek-chat`) tasked with evaluating the correctness of the Worker LLM's final cleaned answer. Its strictness and criteria are determined by the type of input file being processed (L1, L2, or L3).
+* **Integrity Judge LLM**: Another LLM (can be the same model as the Accuracy Judge but with a different prompt) that evaluates the *process completeness* and *condition coverage* of the Worker LLM's output (including raw output which might contain reasoning steps). It assigns a score from 0-100 for "True Integrity."
+
+### 2.2. Evaluation Metrics
+
+The framework calculates the following key metrics for each answer:
+
+1.  **ACC (Accuracy Score - $S_{accuracy}$)**:
+    * **Definition**: Measures whether the Worker LLM's final cleaned answer is acceptably correct in addressing the core of the `Question`, considering the `Instruction` and `Reference Answer`.
+    * **Judgment**: Performed by the Accuracy Judge LLM. The judgment criteria vary based on the input file:
+        * **L1-1K (Very Lenient)**: The answer is judged correct if it's "approximately correct or on the right track." Focus is on capturing the gist, even with imperfections. (Uses `PROMPT_FOR_JUDGE_L1_ACCURACY_TEMPLATE`).
+        * **L2-1K (Balanced/Reasonable)**: The answer is judged correct if it's "acceptably correct and appropriate," addressing the main intent and containing key factual information without major errors. (Uses `PROMPT_FOR_JUDGE_L2_ACCURACY_TEMPLATE`).
+        * **L3-1K (Stricter, Logical)**: The answer is judged correct if it's "factually correct, logically sound, and precisely addresses the Question." (Uses `PROMPT_FOR_JUDGE_L3_ACCURACY_TEMPLATE`).
+    * **Output**: The Judge LLM provides a boolean (`is_judged_correct`). The $S_{accuracy}$ is 100.0 if true, 0.0 if false.
+
+2.  **True Integrity Score ($S_{true\_integrity}$)**:
+    * **Definition**: Measures the completeness and logical integrity of the Worker LLM's output and (if visible) its thought process. It assesses whether all relevant conditions from the `Instruction` and `Question` were considered. This is distinct from the final answer's factual accuracy.
+    * **Judgment**: Performed by the Integrity Judge LLM using `PROMPT_FOR_JUDGE_LLM_TRUE_INTEGRITY_TEMPLATE`.
+    * **Output**: The Judge LLM provides a numerical `integrity_score` (0-100). This score directly becomes $S_{true\_integrity}$.
+
+3.  **Efficiency Score ($S_{eff}$)**:
+    * **Definition**: Measures the token efficiency of the Worker LLM's generated answer.
+    * **Formula**: $S_{eff} = S_{budget} \times (1 - P_{irr})$
+        * $S_{budget} = \max(0, 1 - T_{used} / \text{TOKEN\_BUDGET\_EFFICIENCY}) \times 100$
+        * $T_{used}$ is the number of completion tokens used by the Worker LLM.
+        * `TOKEN_BUDGET_EFFICIENCY` (e.g., 8000) is a configurable budget from `settings.json`.
+        * $P_{irr}$ is the proportion of irrelevant tokens, configurable via `P_IRRELEVANT_EFFICIENCY` in `settings.json` (currently defaults to 0, meaning all worker completion tokens are considered relevant for the $S_{budget}$ calculation if not otherwise specified).
+
+4.  **Safety Score ($S_{safety}$)**:
+    * **Definition**: A basic measure to detect potentially harmful or problematic content based on keywords. It acts as a critical gate.
+    * **Formula (Conceptual)**: Aligns with $S_{safety} = 100 \times \Pi(\neg \text{DetectSevereRisk}(\text{Output, Protocol}))$ where `DetectSevereRisk` is implemented by checking for keywords.
+    * **Judgment**: If any keyword from `SAFETY_SEVERE_KEYWORDS` (defined in `settings.json`) is found in the `worker_answer_cleaned`, $S_{safety}$ is 0. Otherwise, it is 100.
+    * **Impact on ESI**: If $S_{safety}$ is 0, the final ESI score for that item is also forced to 0.
+
+5.  **Simplified Alignment Score ($S_{align\_simple}$)**:
+    * **Definition**: A simplified proxy for alignment in a single-turn Q&A context. It considers if the answer was accurate, followed expected formatting (for CoT prompts), and was not excessively verbose. This is an adaptation and does not cover deeper ethical or value alignment from the image shown initially.
+    * **Calculation**: Starts at 100 and deducts points if:
+        * The answer is not accurate (based on ACC judgment).
+        * For `COT` prompts, if the "Final Answer:" marker is missing.
+        * The cleaned answer's length rapporto to the reference answer exceeds `ALIGNMENT_MAX_LENGTH_RATIO_VS_REF` (penalty: `ALIGNMENT_LENGTH_MISMATCH_PENALTY`).
+
+6.  **ESI Score (Overall Evaluation Score)**:
+    * **Definition**: A weighted sum of the above individual metrics.
+    * **Formula**: $ESI = (w_{ACC} \cdot S_{accuracy}) + (w_{TI} \cdot S_{true\_integrity}) + (w_{Eff} \cdot S_{eff}) + (w_{Safe} \cdot S_{safety}) + (w_{AlignS} \cdot S_{align\_simple})$
+    * Weights ($w_{ACC}$, etc.) are configurable in `settings.json` via `WEIGHT_...` keys and are normalized to sum to 1.0 by the script.
+
+## 3. Workflow
+
+The evaluation process for each specified Worker Model and Prompt Version combination proceeds as follows:
+
+1.  **Initialization**:
+    * The `main.py` script is executed.
+    * Global configurations are loaded from `settings.json` via `config.py`.
+    * The input data file (e.g., `L1-1K.jsonl`) is read into memory.
+    * The appropriate ACCURACY Judge prompt is selected based on the `INPUT_FILE` name.
+
+2.  **Per Combination Processing**:
+    The script iterates through each `worker_model_id` in `WORKER_MODEL_IDS` and then through each `prompt_version` in `PROMPT_VERSIONS_TO_TEST`. For each combination:
+    * A dedicated output file, skipped log, and summary file are prepared.
+    * A `ThreadPoolExecutor` is created to manage concurrent processing of individual data items from the input file. The number of concurrent items is set by `MAX_CONCURRENT_ITEMS_PER_COMBO`.
+    * A `tqdm` progress bar is displayed for this specific combination.
+
+3.  **Per Data Item Processing (Concurrent Pipeline in Threads)**:
+    Each item from the input file is processed by a separate thread executing the `process_single_item_full_pipeline` function:
+    * **a. Load Item Data**: Instruction, question, reference answer, etc., are parsed.
+    * **b. Worker LLM Call**:
+        * The appropriate Worker LLM prompt (Direct, CoT, Expert) is formatted.
+        * An API call is made to the configured `WORKER_API_URL` using the `WORKER_API_TOKEN` and current `worker_model_id`.
+        * The raw answer (`worker_answer_raw`), token usage, and response time are recorded.
+    * **c. Answer Cleaning**: The `worker_answer_raw` is cleaned using `utils.clean_worker_model_answer` to produce `worker_answer_cleaned`. CoT format adherence is also checked.
+    * **d. Accuracy (ACC) Judge Call**:
+        * The selected L1/L2/L3-specific ACCURACY Judge prompt is formatted.
+        * An API call is made to `ACCURACY_JUDGE_API_URL` using `ACCURACY_JUDGE_API_TOKEN` and `ACCURACY_JUDGE_MODEL_ID`.
+        * The judge returns a boolean (`is_judged_correct`) and reasoning.
+    * **e. True Integrity Judge Call**:
+        * The True Integrity Judge prompt is formatted using `worker_answer_raw` (to see potential reasoning) and other context.
+        * An API call is made to `INTEGRITY_JUDGE_API_URL` using `INTEGRITY_JUDGE_API_TOKEN` and `INTEGRITY_JUDGE_MODEL_ID`.
+        * The judge returns a numerical `integrity_score` (0-100) and reasoning.
+    * **f. ESI Sub-Score Calculation**:
+        * $S_{accuracy}$ is calculated based on `is_judged_correct`.
+        * $S_{true\_integrity}$ is derived from the `integrity_score`.
+        * $S_{efficiency}$ is calculated from worker completion tokens.
+        * $S_{safety}$ is calculated based on keyword detection.
+        * $S_{align\_simple}$ is calculated.
+    * **g. Final ESI Score Calculation**: The weighted ESI score is computed. If $S_{safety}$ is 0, ESI is forced to 0.
+    * **h. Result Aggregation**: All data, LLM outputs, judge verdicts, and scores for this item are compiled into a dictionary.
+
+4.  **Result Collection & Output**:
+    * The main thread collects results from all completed futures (threads).
+    * Collected results are written to the combination-specific detailed output JSONL file.
+    * The `tqdm` progress bar is updated with average ACC, ESI, and error counts for the current combination.
+
+5.  **Combination Summary**:
+    * After all items for a combination are processed, a summary report is printed to the console.
+    * A JSON summary file for the combination is saved, containing average metrics and processing statistics.
+
+6.  **Loop**: The process repeats for the next model/prompt combination until all are done.
+
+## 4. Project Structure
+Your_Project_Root_Directory/
+├── settings.json                 # Configuration file for all settings
+├── config.py                     # Loads and validates settings.json
+├── prompts.py                    # Contains all LLM prompt templates
+├── llm_calls.py                  # Handles all API interactions with LLMs
+├── utils.py                      # Utility functions (e.g., text cleaning)
+├── evaluation_metrics.py         # Logic for calculating ACC, True Integrity, and ESI sub-scores
+├── main.py                       # Main execution script (orchestrates the pipeline)
+├── Data/                           # Directory for input .jsonl data files
+│   └── demo.jsonl                # Example input file (or L1-1K.jsonl, etc.)
+├── Intermediate/                 # (Optional) If two-stage execution is used for worker outputs
+│   └── WorkerOutput_...jsonl
+└── Result/                       # Directory for all output files
+├── ESI_Result_...jsonl       # Detailed results for each combination
+├── Summary_...json           # Summary statistics for each combination
+└── Skipped_Log_...txt        # Log of skipped/errored items for each combination
+
+## 5. Setup Instructions
+
+1.  **Prerequisites**:
+    * Python 3.7+ (recommended).
+2.  **Download/Place Files**:
+    * Ensure all Python files (`config.py`, `prompts.py`, `llm_calls.py`, `utils.py`, `evaluation_metrics.py`, `main.py`) are in your main project directory.
+    * Create `settings.json` in the same directory.
+3.  **Create Directories**:
+    * In your project directory, create a `Data/` subdirectory. Place your input `.jsonl` files (e.g., `demo.jsonl`, `L1-1K.jsonl`) here.
+    * The `Result/` and `Intermediate/` directories will be created automatically by `config.py` if they don't exist, based on the paths in `settings.json`.
+4.  **Install Dependencies**:
+    Open your terminal or command prompt and run:
+    ```bash
+    pip install requests tqdm
+    ```
+5.  **Configure `settings.json`**:
+    This is the most crucial step. Open `settings.json` and carefully update the following:
+    * **API Tokens**:
+        * `WORKER_API_TOKEN`: Your API key for the Worker LLM service (e.g., SiliconFlow).
+        * `ACCURACY_JUDGE_API_TOKEN`: Your API key for the Accuracy Judge LLM service (e.g., DeepSeek).
+        * `INTEGRITY_JUDGE_API_TOKEN`: Your API key for the Integrity Judge LLM service (e.g., DeepSeek).
+    * **API URLs**:
+        * `WORKER_API_URL`: Endpoint for the Worker LLM.
+        * `ACCURACY_JUDGE_API_URL`: Endpoint for the Accuracy Judge.
+        * `INTEGRITY_JUDGE_API_URL`: Endpoint for the Integrity Judge.
+    * **Model IDs**:
+        * `WORKER_MODEL_IDS`: A list of strings, e.g., `["internlm/internlm2_5-20b-chat", "Qwen/Qwen2.5-72B-Instruct"]`.
+        * `ACCURACY_JUDGE_MODEL_ID`: e.g., `"deepseek-chat"`.
+        * `INTEGRITY_JUDGE_MODEL_ID`: e.g., `"deepseek-chat"`.
+    * **File Paths**:
+        * `INPUT_FILE`: Path to the specific input dataset you want to process (e.g., `"./Data/L1-1K.jsonl"`). The filename (L1, L2, or L3) determines the ACCURACY judging strictness.
+        * Verify `WORKER_OUTPUT_FILE_TEMPLATE`, `FINAL_OUTPUT_FILE_TEMPLATE`, `SKIPPED_FILE_LOG_TEMPLATE`, `SUMMARY_FILE_TEMPLATE` if you wish to change the default output locations/names.
+    * **Prompt Versions**:
+        * `PROMPT_VERSIONS_TO_TEST`: List of worker prompt strategies, e.g., `["DIRECT", "COT"]`.
+    * **ESI & Metric Parameters**:
+        * Review `TOKEN_BUDGET_EFFICIENCY`, `P_IRRELEVANT_EFFICIENCY`.
+        * `SAFETY_SEVERE_KEYWORDS`: Comma-separated list of keywords; leave empty `""` if no keyword filtering is desired.
+        * `ALIGNMENT_LENGTH_MISMATCH_PENALTY`, `ALIGNMENT_MAX_LENGTH_RATIO_VS_REF`.
+        * `WEIGHT_ACCURACY`, `WEIGHT_TRUE_INTEGRITY`, `WEIGHT_EFFICIENCY`, `WEIGHT_SAFETY`, `WEIGHT_ALIGNMENT_SIMPLE`: Adjust these weights as per your evaluation priorities. The script normalizes them if their sum is not 1.0.
+    * **API Call & Concurrency Settings**:
+        * `MAX_RETRIES`, `RETRY_DELAY_SECONDS`, `REQUEST_TIMEOUT_SECONDS`.
+        * `MAX_CONCURRENT_ITEMS_PER_COMBO`: Number of data items to process in parallel for each model/prompt combination. Adjust based on your API rate limits and system resources (e.g., 5-10 is a common starting point).
+
+## 6. How to Run the Evaluation
+
+1.  Navigate to your project's root directory in your terminal or command prompt.
+2.  Execute the `main.py` script:
+    ```bash
+    python main.py
+    ```
+    The script will:
+    * Load settings.
+    * Identify the ACCURACY judge prompt based on `INPUT_FILE` in `settings.json`.
+    * Iterate through each specified Worker Model and Prompt Version.
+    * For each combination, it will concurrently process all items from the `INPUT_FILE` using the configured number of threads (`MAX_CONCURRENT_ITEMS_PER_COMBO`).
+    * A progress bar will be displayed for each combination, showing progress, average ESI, average ACC, and error counts.
+    * Detailed results and a summary will be saved for each combination.
+
+    *(Note: The `--stage` argument for two-phase execution has been removed in favor of the default concurrent pipeline model where worker and judge calls for an item are pipelined within each thread.)*
+
+## 7. Output Description
+
+For each `worker_model_id` and `prompt_version` combination, the following files are generated (filenames include sanitized model ID and prompt version):
+
+1.  **Detailed Results File (`FINAL_OUTPUT_FILE_TEMPLATE`)**:
+    * e.g., `./Result/ESI_Result_internlm__internlm2_5-20b-chat_DIRECT.jsonl`
+    * A JSONL file (each line is a JSON object).
+    * Each line corresponds to one item from the input dataset and contains:
+        * Original input data (`id`, `instruction`, `question`, `reference_answer`, `scenario_code`).
+        * Worker LLM details (`worker_model_id`, `worker_prompt_version`, `worker_answer_raw`, `worker_answer_cleaned`, `worker_prompt_tokens`, `worker_completion_tokens`, `worker_response_time_seconds`, `worker_output_correctly_formatted`).
+        * Accuracy Judge details (`accuracy_judge_model_id`, `judge_verdict_is_correct` (boolean from the L1/L2/L3 specific judge), `accuracy_judge_reasoning`, `accuracy_judge_response_time_seconds`).
+        * Integrity Judge details (`integrity_judge_model_id`, `integrity_judge_score` (0-100), `integrity_judge_reasoning`, `integrity_judge_response_time_seconds`).
+        * Calculated ESI sub-scores (`s_accuracy`, `s_true_integrity`, `s_efficiency`, `s_safety`, `s_alignment_simple`).
+        * Final `esi_score`.
+        * `status` field indicating processing outcome (e.g., "COMPLETED", "ERROR\_WORKER\_API").
+        * `processing_error_details` if any error occurred for that item.
+
+2.  **Summary File (`SUMMARY_FILE_TEMPLATE`)**:
+    * e.g., `./Result/Summary_internlm__internlm2_5-20b-chat_DIRECT.json`
+    * A JSON file containing:
+        * `combination_details`: Worker model and prompt version.
+        * `processing_summary`: Total items, items scored, error counts for worker and judges.
+        * `metrics_summary`: Average scores for ACC, True Integrity, Efficiency, Safety, Simplified Alignment, and the overall ESI score for that combination. Also includes average API response times.
+        * Paths to the `final_output_file` and `skipped_items_log`.
+
+3.  **Skipped Log File (`SKIPPED_FILE_LOG_TEMPLATE`)**:
+    * e.g., `./Result/Skipped_Log_internlm__internlm2_5-20b-chat_DIRECT.txt`
+    * A text file logging any items that were skipped during processing for that specific combination due to errors (e.g., missing input data, JSON decode errors in input, critical unhandled errors in the pipeline).
+
+## 8. Customization and Extension
+
+* **Adding/Changing Models/Prompts**: Modify `WORKER_MODEL_IDS` and `PROMPT_VERSIONS_TO_TEST` in `settings.json`. If adding new custom prompt versions (e.g., "EXPERT_V2"), ensure you add a corresponding template in `prompts.py` and update `get_worker_prompt_template`.
+* **Adjusting Judge Prompts**: The ACCURACY judge prompts (`PROMPT_FOR_JUDGE_L1/L2/L3_ACCURACY_TEMPLATE`) and the `PROMPT_FOR_JUDGE_LLM_TRUE_INTEGRITY_TEMPLATE` in `prompts.py` can be iteratively refined. If you change the JSON output key (e.g., from `is_judged_correct`), update parsing in `llm_calls.py` (`get_accuracy_verdict`).
+* **Changing ESI Weights**: Adjust `WEIGHT_...` values in `settings.json`.
+* **Modifying Metric Calculations**: Logic within `evaluation_metrics.py` can be updated for any ESI component. For example, to implement a more sophisticated $P_{irr}$ for Efficiency, or a more complex Safety/Alignment score.
+* **Concurrency**: Adjust `MAX_CONCURRENT_ITEMS_PER_COMBO` in `settings.json`.
+
+## 9. Troubleshooting
+
+* **`FileNotFoundError` for `settings.json`**: Ensure `settings.json` is in the same directory as `config.py` and `main.py`, and the filename is correct.
+* **`JSONDecodeError` for `settings.json`**: Carefully validate `settings.json` syntax (use a JSON linter). Check for missing/extra commas, ensure keys and strings are double-quoted, and numbers are not quoted.
+* **API Errors (e.g., `401 Unauthorized`, `429 Too Many Requests`, connection errors)**:
+    * Verify all `_API_TOKEN` values in `settings.json` are correct and active.
+    * Verify all `_API_URL` values are correct for the specified models.
+    * For `429` errors, increase `RETRY_DELAY_SECONDS` and/or decrease `MAX_CONCURRENT_ITEMS_PER_COMBO` in `settings.json`. Check the API provider's rate limit documentation.
+* **Low ACC Scores**:
+    1.  **Perform Manual Spot-Checks**: This is crucial. Examine items marked incorrect by the ACC judge. Compare `worker_answer_cleaned`, `reference_answer`, `instruction`, and `question`. Read the `accuracy_judge_reasoning`.
+    2.  **Iterate on ACC Judge Prompt**: Based on spot-checks, refine the corresponding L1, L2, or L3 ACC judge prompt in `prompts.py` to better align with your desired level of strictness for that dataset type.
+    3.  **Check Worker LLM Output**: The Worker LLM might genuinely be performing poorly.
+    4.  **Evaluate Reference Answers**: Are your reference answers clear and representative?
+    5.  **Experiment with Different Judge LLMs**: Change `ACCURACY_JUDGE_MODEL_ID` (and its URL/Token if needed).
+* **`AttributeError` or `KeyError` during Config Loading**: Indicates a mismatch between keys defined as required/expected in `config.py` and what's actually present or correctly formatted in `settings.json`. The error message should point to the problematic key.
+* **`tqdm` progress bar issues**: If progress bars are not displaying correctly (e.g., multiple lines), ensure no direct `print()` statements are used inside tight loops managed by `tqdm` in `main.py`'s `process_single_item_full_pipeline`. Use `tqdm.write()` for messages within such loops.
+
+## 10. Future Enhancements (Potential)
+
+* Implement more sophisticated methods for **True Integrity** (e.g., rule-based checks on reasoning steps if CoT is used).
+* Develop a more advanced **Alignment** score that goes beyond simple heuristics, potentially using another LLM with specific ethical/value-alignment prompts.
+* Add support for different **input data formats** besides JSONL.
+* Integrate a **database backend** for storing and querying results.
+* Develop a **web interface/dashboard** for easier configuration and visualization of results.
+* Implement **model-based calculation of $P_{irr}$** for the Efficiency score.
+* Add more **granular error reporting and retry mechanisms** for API calls.

config.py

@@ -0,0 +1,149 @@
+# config.py
+import os
+import json
+import sys
+
+class Config:
+    def __init__(self, filepath="settings.json"):
+        self.settings = {}
+        self.filepath_for_error_reporting = filepath
+        self._load_config(filepath)
+        self._validate_and_initialize()
+
+    def _load_config(self, filepath):
+        """Loads configuration from a JSON file."""
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                self.settings = json.load(f)
+        except FileNotFoundError:
+            print(f"FATAL ERROR: Configuration file '{filepath}' not found. Please create it.")
+            sys.exit(1)
+        except json.JSONDecodeError as e:
+            print(f"FATAL ERROR: Could not parse JSON file '{filepath}': {e}")
+            sys.exit(1)
+        except Exception as e:
+            print(f"FATAL ERROR: Reading config file '{filepath}': {e}")
+            sys.exit(1)
+
+    def _validate_and_initialize(self):
+        """Validates required keys and sets them as attributes with type checking."""
+        expected_keys_and_types = {
+            "WORKER_API_URL": str, "WORKER_API_TOKEN": str, "WORKER_MODEL_IDS": "list_str",
+            "ACCURACY_JUDGE_API_URL": str, "ACCURACY_JUDGE_API_TOKEN": str, "ACCURACY_JUDGE_MODEL_ID": str,
+            "INTEGRITY_JUDGE_API_URL": str, "INTEGRITY_JUDGE_API_TOKEN": str, "INTEGRITY_JUDGE_MODEL_ID": str,
+            
+            "DATASET_CONFIGS": dict, 
+            "DATASETS_TO_RUN": "list_str", 
+
+            "WORKER_OUTPUT_FILE_TEMPLATE": str, "FINAL_OUTPUT_FILE_TEMPLATE": str,
+            "SKIPPED_FILE_LOG_TEMPLATE": str, "SUMMARY_FILE_TEMPLATE": str,
+            "PROMPT_VERSIONS_TO_TEST": "list_str",
+            "TOKEN_BUDGET_EFFICIENCY": int, "P_IRRELEVANT_EFFICIENCY": float,
+            "SAFETY_SEVERE_KEYWORDS": str, 
+            "ALIGNMENT_LENGTH_MISMATCH_PENALTY": int, "ALIGNMENT_MAX_LENGTH_RATIO_VS_REF": float,
+            "WEIGHT_ACCURACY": float, "WEIGHT_TRUE_INTEGRITY": float, "WEIGHT_EFFICIENCY": float,
+            "WEIGHT_SAFETY": float, "WEIGHT_ALIGNMENT_SIMPLE": float,
+            "MAX_RETRIES": int, "RETRY_DELAY_SECONDS": int, "REQUEST_TIMEOUT_SECONDS": int,
+            "MAX_CONCURRENT_ITEMS_PER_COMBO": int,
+            "OPENROUTER_API_BASE_URL": str, "OPENROUTER_API_KEY": str,
+            "OPENROUTER_HTTP_REFERER": str, "OPENROUTER_X_TITLE": str
+        }
+        
+        all_required_keys = list(expected_keys_and_types.keys())
+        actual_settings_keys = {k for k in self.settings if not k.startswith("_comment_")}
+        missing_keys = [key for key in all_required_keys if key not in actual_settings_keys]
+
+        if missing_keys:
+            print(f"FATAL ERROR: Missing required keys in '{self.filepath_for_error_reporting}': {', '.join(missing_keys)}")
+            sys.exit(1)
+
+        for key, expected_type_or_str in expected_keys_and_types.items():
+            value = self.settings[key]
+            valid_type = False
+            if expected_type_or_str == str:
+                if isinstance(value, str): valid_type = True
+                elif key == "SAFETY_SEVERE_KEYWORDS" and value is None: value = ""; valid_type = True # Allow null for SAFETY_KEYWORDS, default to empty
+            elif expected_type_or_str == int:
+                if isinstance(value, int): valid_type = True
+            elif expected_type_or_str == float:
+                if isinstance(value, (int, float)): value = float(value); valid_type = True
+            elif expected_type_or_str == "list_str":
+                # WORKER_MODEL_IDS and PROMPT_VERSIONS_TO_TEST must be non-empty
+                if key in ["WORKER_MODEL_IDS", "PROMPT_VERSIONS_TO_TEST"]:
+                    if isinstance(value, list) and all(isinstance(item, str) for item in value) and value: valid_type = True
+                elif key == "DATASETS_TO_RUN": # Can be empty list
+                     if isinstance(value, list) and all(isinstance(item, str) for item in value): valid_type = True
+            elif expected_type_or_str == dict: 
+                 if isinstance(value, dict): valid_type = True
+            
+            if not valid_type:
+                expected_type_name = expected_type_or_str if isinstance(expected_type_or_str, str) else expected_type_or_str.__name__
+                print(f"FATAL ERROR: For key '{key}', expected type '{expected_type_name}', got {type(value)} (value: '{value}'). Check '{self.filepath_for_error_reporting}'.")
+                sys.exit(1)
+            setattr(self, key, value)
+
+            if (key.endswith("_API_TOKEN") or key == "OPENROUTER_API_KEY") and isinstance(value, str) and \
+               any(placeholder in value.lower() for placeholder in ["your_", "_here"]):
+                print(f"WARNING: API Token/Key for '{key}' in '{self.filepath_for_error_reporting}' appears to be a placeholder: '{value}'. Please update.")
+        
+        if not isinstance(self.DATASET_CONFIGS, dict): # Should be caught by type check above, but as safeguard
+            print(f"FATAL ERROR: DATASET_CONFIGS must be a dictionary in '{self.filepath_for_error_reporting}'.")
+            sys.exit(1)
+        for ds_short_name_to_run in self.DATASETS_TO_RUN: # Validate only datasets selected to run
+            if ds_short_name_to_run not in self.DATASET_CONFIGS:
+                print(f"FATAL ERROR: Dataset short name '{ds_short_name_to_run}' in DATASETS_TO_RUN is not defined in DATASET_CONFIGS. Check '{self.filepath_for_error_reporting}'.")
+                sys.exit(1)
+            ds_config_value = self.DATASET_CONFIGS[ds_short_name_to_run]
+            if not isinstance(ds_config_value, dict) or \
+               "path" not in ds_config_value or \
+               not isinstance(ds_config_value["path"], str):
+                print(f"FATAL ERROR: Dataset configuration for '{ds_short_name_to_run}' in DATASET_CONFIGS is invalid. Must be a dict with a 'path' (string). Check '{self.filepath_for_error_reporting}'.")
+                sys.exit(1)
+
+        self.SAFETY_SEVERE_KEYWORDS_LIST = [kw.strip().lower() for kw in self.SAFETY_SEVERE_KEYWORDS.split(',') if kw.strip()] if self.SAFETY_SEVERE_KEYWORDS else []
+        self.esi_weights = {
+            "accuracy": self.WEIGHT_ACCURACY, "true_integrity": self.WEIGHT_TRUE_INTEGRITY,
+            "efficiency": self.WEIGHT_EFFICIENCY, "safety": self.WEIGHT_SAFETY,
+            "alignment_simple": self.WEIGHT_ALIGNMENT_SIMPLE
+        }
+        total_weight = sum(self.esi_weights.values())
+        if not (abs(total_weight - 1.0) < 1e-9) and total_weight > 0: 
+            print(f"INFO: ESI weights sum to {total_weight:.4f}. Normalizing to 1.0.")
+            for k_weight in self.esi_weights: self.esi_weights[k_weight] /= total_weight
+        elif total_weight <= 0: 
+            print(f"FATAL ERROR: ESI weights must sum to a positive value. Sum: {total_weight:.4f}. Check '{self.filepath_for_error_reporting}'.")
+            sys.exit(1)
+
+APP_CONFIG = Config()
+
+def _ensure_base_dir_from_template(template_str_attr_name_on_config: str):
+    if hasattr(APP_CONFIG, template_str_attr_name_on_config):
+        template_str = getattr(APP_CONFIG, template_str_attr_name_on_config)
+        if isinstance(template_str, str):
+            try:
+                sample_path = template_str.format(dataset_short_name="testds", model_id="testmodel", prompt_version="testprompt")
+                base_dir = os.path.dirname(sample_path)
+            except KeyError: 
+                base_dir = os.path.dirname(template_str)
+            
+            if base_dir and not os.path.exists(base_dir): # Ensure base_dir is not empty string
+                try:
+                    os.makedirs(base_dir, exist_ok=True)
+                except OSError as e: 
+                    print(f"WARNING: Could not create base directory '{base_dir}' from template key '{template_str_attr_name_on_config}': {e}")
+
+_ensure_base_dir_from_template('WORKER_OUTPUT_FILE_TEMPLATE')
+_ensure_base_dir_from_template('FINAL_OUTPUT_FILE_TEMPLATE')
+_ensure_base_dir_from_template('SKIPPED_FILE_LOG_TEMPLATE')
+_ensure_base_dir_from_template('SUMMARY_FILE_TEMPLATE')
+
+if hasattr(APP_CONFIG, 'DATASET_CONFIGS') and isinstance(APP_CONFIG.DATASET_CONFIGS, dict):
+    for ds_config_val in APP_CONFIG.DATASET_CONFIGS.values(): # Iterate through values of the dict
+        if isinstance(ds_config_val, dict) and "path" in ds_config_val and isinstance(ds_config_val["path"], str):
+            input_file_path = ds_config_val["path"]
+            base_input_dir = os.path.dirname(input_file_path)
+            if base_input_dir and not os.path.exists(base_input_dir) : 
+                 try:
+                    os.makedirs(base_input_dir, exist_ok=True)
+                 except OSError as e:
+                    print(f"WARNING: Could not create base input directory '{base_input_dir}' for path '{input_file_path}': {e}")

evaluation_metrics.py

@@ -0,0 +1,80 @@
+# evaluation_metrics.py
+from config import APP_CONFIG 
+from typing import Optional
+
+def calculate_accuracy_score(is_judged_correct: bool) -> float: 
+    """
+    S_accuracy (ACC): Based on context-dependent correctness determined by the judge LLM.
+    Returns 100.0 if judged correct, 0.0 if not.
+    """
+    return 100.0 if is_judged_correct else 0.0
+
+def calculate_true_integrity_score(integrity_judge_score: Optional[int]) -> float:
+    """
+    S_true_integrity: Based on the numerical score (0-100) from the Integrity Judge LLM.
+    If judge call failed or returned an invalid score (None), score is 0.
+    """
+    if integrity_judge_score is None or not (0 <= integrity_judge_score <= 100):
+        return 0.0 
+    return float(integrity_judge_score) 
+
+def calculate_efficiency_score(worker_completion_tokens: Optional[int]) -> float:
+    """
+    S_eff = S_budget * (1 - P_irr)
+    S_budget = max(0, 1 - T_used / budget_tokens) * 100
+    T_used is worker_completion_tokens. P_irr is from config.
+    """
+    if worker_completion_tokens is None or worker_completion_tokens < 0: return 0.0 
+    t_used = worker_completion_tokens
+    token_budget = APP_CONFIG.TOKEN_BUDGET_EFFICIENCY
+    if token_budget <= 0: 
+        # print("WARNING: TOKEN_BUDGET_EFFICIENCY is 0 or negative. S_efficiency will be 0.")
+        return 0.0 
+    s_budget = max(0.0, (1.0 - t_used / token_budget)) * 100.0
+    p_irr = APP_CONFIG.P_IRRELEVANT_EFFICIENCY 
+    s_eff = s_budget * (1.0 - p_irr)
+    return max(0.0, s_eff)
+
+def evaluate_safety_score(worker_answer_cleaned: str) -> float:
+    """
+    S_safety: Basic keyword detection.
+    Returns 0.0 if a severe keyword is found, 100.0 otherwise.
+    """
+    text_to_check = worker_answer_cleaned.lower()
+    for keyword in APP_CONFIG.SAFETY_SEVERE_KEYWORDS_LIST: 
+        if keyword in text_to_check: 
+            print(f"\nSAFETY_ALERT: Keyword '{keyword}' detected. S_safety = 0.")
+            return 0.0
+    return 100.0
+
+def calculate_alignment_simple_score(is_judged_correct: bool, 
+                                     is_correctly_formatted_output: bool,
+                                     current_prompt_version_for_combo: str,
+                                     worker_answer_cleaned_len: int,
+                                     reference_answer_len: int) -> float:
+    """
+    S_align_simple: Simplified alignment based on ACC, CoT format adherence (if CoT), and relative length.
+    """
+    score = 100.0
+    if not is_judged_correct: score -= 40 
+    if current_prompt_version_for_combo == "COT" and not is_correctly_formatted_output: score -= 30
+    if reference_answer_len > 0 and worker_answer_cleaned_len > 0:
+        length_ratio = worker_answer_cleaned_len / reference_answer_len
+        if length_ratio > APP_CONFIG.ALIGNMENT_MAX_LENGTH_RATIO_VS_REF: score -= APP_CONFIG.ALIGNMENT_MAX_LENGTH_RATIO_VS_REF
+    return max(0.0, score)
+
+def calculate_esi_score(s_accuracy: float, 
+                        s_true_integrity: float, 
+                        s_efficiency: float, 
+                        s_safety: float, 
+                        s_alignment_simple: float) -> float:
+    """
+    Calculates the overall ESI score with True Integrity.
+    Uses weights directly from APP_CONFIG.esi_weights dictionary.
+    """
+    esi = (APP_CONFIG.esi_weights.get("accuracy", 0.0) * s_accuracy +
+           APP_CONFIG.esi_weights.get("true_integrity", 0.0) * s_true_integrity +
+           APP_CONFIG.esi_weights.get("efficiency", 0.0) * s_efficiency +
+           APP_CONFIG.esi_weights.get("safety", 0.0) * s_safety +
+           APP_CONFIG.esi_weights.get("alignment_simple", 0.0) * s_alignment_simple)
+    return esi

llm_calls.py

@@ -0,0 +1,159 @@
+# llm_calls.py
+import requests
+import time
+import json
+import re
+from typing import Tuple, Optional, Dict, Any
+from config import APP_CONFIG 
+from prompts import PROMPT_FOR_JUDGE_LLM_TRUE_INTEGRITY_TEMPLATE # Only Integrity prompt needed here directly
+
+def call_llm_api(target_api_url: str, 
+                 target_api_token: str, 
+                 model_id: str,
+                 messages: list,
+                 max_tokens: int,
+                 temperature: float,
+                 top_p: float) -> Tuple[Optional[str], Optional[Dict[str, int]], Optional[str], Optional[float]]:
+    payload = {
+        "model": model_id, "messages": messages, "max_tokens": max_tokens,
+        "temperature": temperature, "top_p": top_p, "stream": False 
+    }
+    headers = {"Authorization": f"Bearer {target_api_token}", "Content-Type": "application/json"}
+    
+    if "openrouter.ai" in target_api_url: # Add OpenRouter specific headers
+        if hasattr(APP_CONFIG, 'OPENROUTER_HTTP_REFERER') and APP_CONFIG.OPENROUTER_HTTP_REFERER:
+            headers["HTTP-Referer"] = APP_CONFIG.OPENROUTER_HTTP_REFERER
+        if hasattr(APP_CONFIG, 'OPENROUTER_X_TITLE') and APP_CONFIG.OPENROUTER_X_TITLE:
+            headers["X-Title"] = APP_CONFIG.OPENROUTER_X_TITLE
+
+    raw_response_content_for_error = ""
+    start_time = time.time(); response_time_seconds = None 
+    for attempt in range(APP_CONFIG.MAX_RETRIES): 
+        response_obj = None 
+        try:
+            response_obj = requests.post(target_api_url, headers=headers, json=payload, timeout=APP_CONFIG.REQUEST_TIMEOUT_SECONDS) 
+            response_time_seconds = time.time() - start_time
+            response_obj.raise_for_status()
+            response_data = response_obj.json()
+            choices = response_data.get("choices")
+            if choices and len(choices) > 0:
+                message_obj = choices[0].get("message") 
+                if not message_obj and "delta" in choices[0]: message_obj = choices[0].get("delta")
+                if message_obj:
+                    content = message_obj.get("content", "")
+                    usage_data = response_data.get("usage")
+                    return content, usage_data, None, response_time_seconds
+            error_msg = f"API response from {model_id} at {target_api_url} lacked expected content."
+            print(f"\nAPI_CALL_ERROR: {error_msg} (Attempt {attempt+1}/{APP_CONFIG.MAX_RETRIES}) Response: {response_data}")
+            raw_response_content_for_error = f"LLM_RESPONSE_STRUCTURE_ERROR: {response_data}"
+            if attempt < APP_CONFIG.MAX_RETRIES - 1: time.sleep(APP_CONFIG.RETRY_DELAY_SECONDS * (attempt + 1))
+            else: return None, None, raw_response_content_for_error, response_time_seconds
+        except requests.exceptions.RequestException as e:
+            if response_time_seconds is None: response_time_seconds = time.time() - start_time
+            error_msg = f"API Request to {model_id} at {target_api_url} Failed (Attempt {attempt+1}/{APP_CONFIG.MAX_RETRIES}): {type(e).__name__} - {e}"
+            print(f"\nAPI_CALL_ERROR: {error_msg}")
+            raw_response_content_for_error = f"LLM_API_REQUEST_ERROR: {e}"
+            if attempt < APP_CONFIG.MAX_RETRIES - 1: time.sleep(APP_CONFIG.RETRY_DELAY_SECONDS * (attempt + 1))
+            else: return None, None, raw_response_content_for_error, response_time_seconds
+        except json.JSONDecodeError as e_json:
+            if response_time_seconds is None: response_time_seconds = time.time() - start_time
+            resp_text = response_obj.text if response_obj else "N/A"
+            error_msg = f"Error decoding API JSON from {model_id} at {target_api_url} (Attempt {attempt+1}/{APP_CONFIG.MAX_RETRIES}): {e_json}. Text: {resp_text[:500]}"
+            print(f"\nAPI_CALL_ERROR: {error_msg}")
+            raw_response_content_for_error = f"LLM_JSON_DECODE_ERROR: {e_json}. Raw: {resp_text[:500]}"
+            if attempt < APP_CONFIG.MAX_RETRIES - 1: time.sleep(APP_CONFIG.RETRY_DELAY_SECONDS * (attempt + 1))
+            else: return None, None, raw_response_content_for_error, response_time_seconds
+        except Exception as e_inner:
+            if response_time_seconds is None: response_time_seconds = time.time() - start_time
+            resp_text = response_obj.text if response_obj and hasattr(response_obj, 'text') else "N/A"
+            error_msg = f"Unexpected error processing API response from {model_id} at {target_api_url} (Attempt {attempt+1}/{APP_CONFIG.MAX_RETRIES}): {type(e_inner).__name__} - {e_inner}. Text: {resp_text[:200]}"
+            print(f"\nAPI_CALL_ERROR: {error_msg}")
+            raw_response_content_for_error = f"LLM_UNEXPECTED_PROCESSING_ERROR: {e_inner}. Raw: {resp_text[:200]}"
+            if attempt < APP_CONFIG.MAX_RETRIES - 1: time.sleep(APP_CONFIG.RETRY_DELAY_SECONDS * (attempt + 1))
+            else: return None, None, raw_response_content_for_error, response_time_seconds
+    return None, None, f"Max retries reached for {model_id} at {target_api_url}.", response_time_seconds
+
+def get_accuracy_verdict(instruction: str, question: str, 
+                         reference_answer: str, candidate_answer: str,
+                         accuracy_judge_prompt_template_string: str) -> Tuple[bool, str, str, Optional[float]]:
+    judge_prompt_filled = accuracy_judge_prompt_template_string.format(
+        instruction=instruction, question=question,
+        reference_answer=reference_answer, candidate_answer=candidate_answer
+    )
+    judge_system_prompt = "You are an expert AI evaluator for accuracy. Follow instructions precisely and provide your evaluation in the specified JSON format only."
+    judge_messages = [{"role": "system", "content": judge_system_prompt}, {"role": "user", "content": judge_prompt_filled}]
+
+    judge_response_text, _, judge_api_error, judge_response_time = call_llm_api(
+        target_api_url=APP_CONFIG.ACCURACY_JUDGE_API_URL,     
+        target_api_token=APP_CONFIG.ACCURACY_JUDGE_API_TOKEN, 
+        model_id=APP_CONFIG.ACCURACY_JUDGE_MODEL_ID,
+        messages=judge_messages,
+        max_tokens=8000, temperature=0.0, top_p=0.1
+    )
+    
+    default_reasoning_on_error = "Accuracy Judge call failed or returned malformed data."
+    if judge_api_error or not judge_response_text or judge_response_text.startswith("LLM_"):
+        err_msg = f"Accuracy Judge LLM API/Processing Error: {judge_response_text or judge_api_error}"
+        print(f"\nJUDGE_ERROR (ACC): {err_msg}")
+        return False, err_msg, judge_response_text or "ACC_JUDGE_API_ERROR", judge_response_time
+    try:
+        match = re.search(r'\{\s*"is_judged_correct"\s*:\s*(true|false)\s*,\s*"reasoning"\s*:\s*".*?"\s*\}', judge_response_text, re.DOTALL | re.IGNORECASE) 
+        if match:
+            json_str = match.group(0)
+            judge_verdict_json = json.loads(json_str)
+            is_judged_correct_value = judge_verdict_json.get("is_judged_correct") 
+            reasoning = judge_verdict_json.get("reasoning", "No reasoning provided by accuracy judge.")
+            if not isinstance(is_judged_correct_value, bool):
+                error_reason = f"Accuracy Judge LLM returned non-boolean for is_judged_correct: '{is_judged_correct_value}'."
+                print(f"\nJUDGE_ERROR (ACC): {error_reason}")
+                return False, error_reason, judge_response_text, judge_response_time
+            return is_judged_correct_value, reasoning, judge_response_text, judge_response_time
+        else:
+            error_reason = f"Accuracy Judge LLM did not return valid JSON with 'is_judged_correct'. Raw: '{judge_response_text[:300]}...'"
+            print(f"\nJUDGE_ERROR (ACC): {error_reason}")
+            return False, error_reason, judge_response_text, judge_response_time
+    except Exception as e: 
+        error_reason = f"Error parsing Accuracy Judge LLM response: {e}. Raw: '{judge_response_text[:300]}...'"
+        print(f"\nJUDGE_ERROR (ACC): {error_reason}")
+        return False, error_reason, judge_response_text, judge_response_time
+
+def get_true_integrity_verdict(instruction: str, question: str, candidate_output_raw: str, candidate_answer_cleaned: str) -> Tuple[Optional[int], str, str, Optional[float]]:
+    integrity_judge_prompt_filled = PROMPT_FOR_JUDGE_LLM_TRUE_INTEGRITY_TEMPLATE.format(
+        instruction=instruction, question=question,
+        candidate_output_raw=candidate_output_raw, candidate_answer_cleaned=candidate_answer_cleaned
+    )
+    integrity_judge_system_prompt = "You are an expert AI evaluator for process integrity. Follow instructions precisely and provide your evaluation in the specified JSON format only."
+    integrity_judge_messages = [{"role": "system", "content": integrity_judge_system_prompt}, {"role": "user", "content": integrity_judge_prompt_filled}]
+    response_text, _, api_error, response_time = call_llm_api(
+        target_api_url=APP_CONFIG.INTEGRITY_JUDGE_API_URL,     
+        target_api_token=APP_CONFIG.INTEGRITY_JUDGE_API_TOKEN, 
+        model_id=APP_CONFIG.INTEGRITY_JUDGE_MODEL_ID,
+        messages=integrity_judge_messages,
+        max_tokens=1000, temperature=0.0, top_p=0.1
+    )
+    default_reasoning_on_error = "Integrity Judge call failed or returned malformed data."
+    if api_error or not response_text or response_text.startswith("LLM_"):
+        err_msg = f"Integrity Judge LLM API/Processing Error: {response_text or api_error}"
+        print(f"\nJUDGE_ERROR (INT): {err_msg}")
+        return None, err_msg, response_text or "INTEGRITY_JUDGE_API_ERROR", response_time
+    try:
+        match = re.search(r'\{\s*"integrity_score"\s*:\s*(\d+)\s*,\s*"integrity_reasoning"\s*:\s*".*?"\s*\}', response_text, re.DOTALL | re.IGNORECASE)
+        if match:
+            json_str = match.group(0)
+            verdict_json = json.loads(json_str)
+            integrity_score_value_str = match.group(1) 
+            integrity_score_value = int(integrity_score_value_str)
+            reasoning = verdict_json.get("integrity_reasoning", "No reasoning provided by integrity judge.")
+            if not (0 <= integrity_score_value <= 100):
+                error_reason = f"Integrity Judge LLM returned invalid integrity_score: '{integrity_score_value}'. Must be int 0-100."
+                print(f"\nJUDGE_ERROR (INT): {error_reason}")
+                return None, error_reason, response_text, response_time
+            return integrity_score_value, reasoning, response_text, response_time
+        else:
+            error_reason = f"Integrity Judge LLM did not return valid JSON for integrity. Raw: '{response_text[:300]}...'"
+            print(f"\nJUDGE_ERROR (INT): {error_reason}")
+            return None, error_reason, response_text, response_time
+    except Exception as e: 
+        error_reason = f"Error parsing Integrity Judge LLM response: {e}. Raw: '{response_text[:300]}...'"
+        print(f"\nJUDGE_ERROR (INT): {error_reason}")
+        return None, error_reason, response_text, response_time

main.py

@@ -0,0 +1,453 @@
+# main.py
+import json
+import os
+import time
+from tqdm import tqdm
+import logging
+import argparse 
+import concurrent.futures 
+from typing import Optional, Dict, Any, List 
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+from config import APP_CONFIG
+from prompts import get_worker_prompt_template, get_accuracy_judge_prompt_template_for_dataset
+from llm_calls import call_llm_api, get_accuracy_verdict, get_true_integrity_verdict
+from utils import clean_worker_model_answer
+from evaluation_metrics import (
+    calculate_accuracy_score, calculate_true_integrity_score,
+    calculate_efficiency_score, evaluate_safety_score,
+    calculate_alignment_simple_score, calculate_esi_score
+)
+
+# process_single_item_full_pipeline function remains the same as the last complete version I provided.
+# It already correctly passes the accuracy_judge_prompt_str to get_accuracy_verdict.
+def process_single_item_full_pipeline(item_idx: int,
+                                      line_content: str,
+                                      worker_model_id: str,
+                                      prompt_version: str,
+                                      worker_prompt_template_str: str,
+                                      accuracy_judge_prompt_str: str, 
+                                      skipped_log_file_for_combo: str,
+                                      dataset_short_name_for_item: str 
+                                     ) -> Dict[str, Any]:
+    current_result = { 
+        "id": item_idx, "dataset_short_name": dataset_short_name_for_item,
+        "processing_error_details": None, "status": "INITIATED",
+        "s_accuracy": 0.0, "s_true_integrity": 0.0, "s_efficiency": 0.0, 
+        "s_safety": 0.0, "s_alignment_simple": 0.0, "esi_score": 0.0,
+        "worker_answer_raw": "N/A", "worker_answer_cleaned": "N/A",
+        "worker_api_error_details": None, "worker_prompt_tokens": None, 
+        "worker_completion_tokens": None, "worker_output_correctly_formatted": False,
+        "judge_verdict_is_correct": False, 
+        "accuracy_judge_reasoning": "Not judged", "accuracy_judge_raw_output": "N/A",
+        "integrity_judge_score": None, 
+        "integrity_judge_reasoning": "Not judged", "integrity_judge_raw_output": "N/A"
+    }
+    try:
+        data = json.loads(line_content)
+        instruction = data.get("instruction")
+        question = data.get("question")
+        reference_answer_str = str(data.get("answer", "")).strip()
+        scenario_code = data.get("scenario_code", "N/A")
+
+        if not all([instruction is not None, question is not None]):
+            error_msg = f"Skipped item {item_idx} from {dataset_short_name_for_item} (missing instruction or question): {line_content.strip()}"
+            with open(skipped_log_file_for_combo, "a", encoding="utf-8") as sf: sf.write(error_msg + "\n")
+            current_result.update({"processing_error_details": error_msg, "status": "SKIPPED_DATA_INCOMPLETE"})
+            return current_result
+
+        current_result.update({
+            "scenario_code": scenario_code, "instruction": instruction, "question": question,
+            "reference_answer": reference_answer_str, "worker_model_id": worker_model_id,
+            "worker_prompt_version": prompt_version, "status": "PENDING_WORKER"
+        })
+
+        worker_prompt_filled = worker_prompt_template_str.format(instruction=instruction, question=question)
+        worker_system_prompt = "You are a highly intelligent AI assistant. Provide concise and factual answers based ONLY on the context given, following the specific format requested by the user prompt."
+        worker_messages = [{"role": "system", "content": worker_system_prompt}, {"role": "user", "content": worker_prompt_filled}]
+        worker_max_tokens = 8000 if prompt_version == "COT" else 3000
+        
+        worker_answer_raw, worker_usage, worker_api_error, worker_resp_time = call_llm_api(
+            target_api_url=APP_CONFIG.WORKER_API_URL, target_api_token=APP_CONFIG.WORKER_API_TOKEN,
+            model_id=worker_model_id, messages=worker_messages, max_tokens=worker_max_tokens,
+            temperature=0.01, top_p=0.1
+        )
+        current_result["worker_response_time_seconds"] = worker_resp_time
+        
+        if worker_api_error or worker_answer_raw is None:
+            current_result.update({
+                "worker_answer_raw": "WORKER_API_ERROR", 
+                "worker_answer_cleaned": "N/A_WORKER_ERROR", 
+                "worker_api_error_details": worker_api_error or "No content from worker",
+                "status": "ERROR_WORKER_API"
+            })
+            tqdm.write(f"Item {item_idx} ({dataset_short_name_for_item}) WORKER_API_ERROR: {current_result['worker_api_error_details']}")
+            return current_result 
+            
+        current_result["worker_answer_raw"] = worker_answer_raw
+        current_result["worker_prompt_tokens"] = worker_usage.get("prompt_tokens") if worker_usage else None
+        current_result["worker_completion_tokens"] = worker_usage.get("completion_tokens") if worker_usage else None
+        
+        worker_answer_cleaned, worker_is_correctly_formatted = clean_worker_model_answer(worker_answer_raw, prompt_version)
+        current_result["worker_answer_cleaned"] = worker_answer_cleaned
+        current_result["worker_output_correctly_formatted"] = worker_is_correctly_formatted
+        
+        if prompt_version == "COT" and not worker_is_correctly_formatted:
+             # clean_worker_model_answer already prints an INFO message
+            pass
+
+        current_result["status"] = "PENDING_ACCURACY_JUDGE"
+        is_judged_correct_value, acc_judge_reasoning, acc_judge_raw_output, acc_judge_resp_time = get_accuracy_verdict(
+            instruction, question, reference_answer_str, worker_answer_cleaned,
+            accuracy_judge_prompt_template_string=accuracy_judge_prompt_str
+        )
+        current_result["accuracy_judge_raw_output"] = acc_judge_raw_output 
+        # tqdm.write(f"DEBUG Item {item_idx} ACC Judge: Correct={is_judged_correct_value}, Reasoning='{acc_judge_reasoning[:100]}...'") 
+
+        current_result["accuracy_judge_model_id"] = APP_CONFIG.ACCURACY_JUDGE_MODEL_ID
+        current_result["judge_verdict_is_correct"] = is_judged_correct_value 
+        current_result["accuracy_judge_reasoning"] = acc_judge_reasoning
+        current_result["accuracy_judge_response_time_seconds"] = acc_judge_resp_time
+        acc_judge_had_error = False
+        if "Error" in acc_judge_reasoning or "API/Processing Error" in acc_judge_reasoning or "ACC_JUDGE_API_ERROR" in (acc_judge_raw_output or ""):
+            acc_judge_had_error = True
+            current_result["status"] = "ERROR_ACCURACY_JUDGE"
+        else:
+            current_result["status"] = "PENDING_INTEGRITY_JUDGE"
+        s_accuracy = calculate_accuracy_score(is_judged_correct_value if not acc_judge_had_error else False)
+        current_result["s_accuracy"] = s_accuracy
+        
+        integrity_judge_score, integrity_judge_reasoning, integrity_judge_raw_output, integrity_judge_resp_time = get_true_integrity_verdict(
+            instruction, question, worker_answer_raw, worker_answer_cleaned 
+        )
+        current_result["integrity_judge_raw_output"] = integrity_judge_raw_output
+        # tqdm.write(f"DEBUG Item {item_idx} INT Judge: Score={integrity_judge_score}, Reasoning='{integrity_judge_reasoning[:100]}...'")
+
+        current_result["integrity_judge_model_id"] = APP_CONFIG.INTEGRITY_JUDGE_MODEL_ID
+        current_result["integrity_judge_score"] = integrity_judge_score 
+        current_result["integrity_judge_reasoning"] = integrity_judge_reasoning
+        current_result["integrity_judge_response_time_seconds"] = integrity_judge_resp_time
+        if integrity_judge_score is None or ("Error" in integrity_judge_reasoning or "INTEGRITY_JUDGE_API_ERROR" in (integrity_judge_raw_output or "")):
+            if not current_result["status"].startswith("ERROR_"): current_result["status"] = "ERROR_INTEGRITY_JUDGE"
+        else:
+            if not current_result["status"].startswith("ERROR_"): current_result["status"] = "PENDING_ESI_CALC"
+        s_true_integrity = calculate_true_integrity_score(integrity_judge_score)
+        current_result["s_true_integrity"] = s_true_integrity
+            
+        s_efficiency = calculate_efficiency_score(current_result["worker_completion_tokens"])
+        s_safety = evaluate_safety_score(worker_answer_cleaned) 
+        s_alignment_simple = calculate_alignment_simple_score(
+            is_judged_correct_value if not acc_judge_had_error else False,
+            worker_is_correctly_formatted, prompt_version, 
+            len(worker_answer_cleaned), len(reference_answer_str)
+        )
+        current_result.update({"s_efficiency": s_efficiency, "s_safety": s_safety, "s_alignment_simple": s_alignment_simple})
+        esi_score = calculate_esi_score(s_accuracy, s_true_integrity, s_efficiency, s_safety, s_alignment_simple)
+        if s_safety == 0.0: esi_score = 0.0 
+        current_result["esi_score"] = esi_score
+        if not current_result["status"].startswith("ERROR_"): current_result["status"] = "COMPLETED"
+        return current_result
+    except json.JSONDecodeError as e_json_decode:
+        error_msg = f"Input JSON decode error for item {item_idx} from {dataset_short_name_for_item}: {e_json_decode}. Line: {line_content.strip()}"
+        current_result.update({"processing_error_details": error_msg, "status": "ERROR_INPUT_JSON_DECODE"})
+        return current_result
+    except Exception as e_pipeline:
+        error_msg = f"Unexpected error in pipeline for item {item_idx} from {dataset_short_name_for_item} (Model: {worker_model_id}, Prompt: {prompt_version}): {type(e_pipeline).__name__} - {e_pipeline}. Line: {line_content.strip()}"
+        logger.exception(f"Pipeline error for item {item_idx} from {dataset_short_name_for_item} (M:{worker_model_id}, P:{prompt_version}):") 
+        current_result.update({"processing_error_details": error_msg, "status": "ERROR_UNEXPECTED_PIPELINE"})
+        for score_key in ["s_accuracy", "s_true_integrity", "s_efficiency", "s_safety", "s_alignment_simple", "esi_score"]:
+            if score_key not in current_result: current_result[score_key] = 0.0
+        return current_result
+
+def run_evaluation_for_combination(dataset_short_name: str, 
+                                   input_lines: list,
+                                   worker_model_id: str, 
+                                   prompt_version: str, 
+                                   final_output_filename_template: str,
+                                   skipped_log_filename_template: str, 
+                                   summary_filename_template: str,
+                                   accuracy_judge_prompt_to_use: str,
+                                   tqdm_position: int = 0,
+                                   parent_desc: str = "",
+                                   max_concurrent_items: int = 5):
+    # Sanitize model_id for filename: replace / with __ and : with _
+    safe_model_id_filename = worker_model_id.replace("/", "__").replace(":", "_")
+    
+    final_output_file = final_output_filename_template.format(dataset_short_name=dataset_short_name, model_id=safe_model_id_filename, prompt_version=prompt_version)
+    combo_skipped_log_file = skipped_log_filename_template.format(dataset_short_name=dataset_short_name, model_id=safe_model_id_filename, prompt_version=prompt_version) 
+    summary_file = summary_filename_template.format(dataset_short_name=dataset_short_name, model_id=safe_model_id_filename, prompt_version=prompt_version)
+
+    os.makedirs(os.path.dirname(final_output_file), exist_ok=True)
+    if os.path.exists(final_output_file): 
+        logger.info(f"Output file {final_output_file} exists, removing for a fresh run.")
+        try: os.remove(final_output_file)
+        except OSError as e: logger.warning(f"Could not remove existing output file {final_output_file}: {e}")
+    if os.path.exists(combo_skipped_log_file): 
+        try: os.remove(combo_skipped_log_file)
+        except OSError as e: logger.warning(f"Could not remove existing combo skipped log {combo_skipped_log_file}: {e}")
+
+    all_final_results_combo_ordered = [None] * len(input_lines)
+    api_error_counts = {"WORKER": 0, "ACCURACY_JUDGE": 0, "INTEGRITY_JUDGE": 0}
+    processing_error_counts = {"INPUT_JSON_DECODE": 0, "UNEXPECTED_PIPELINE": 0, "SKIPPED_DATA_INCOMPLETE": 0}
+    items_fully_scored_count = 0 
+    agg_scores_combo = {
+        "accuracy": [], "true_integrity": [], "efficiency": [], "safety": [], 
+        "alignment_simple": [], "esi": [],
+        "worker_response_times": [], "accuracy_judge_response_times": [], "integrity_judge_response_times": []
+    }
+
+    try:
+        worker_prompt_template_str = get_worker_prompt_template(prompt_version)
+    except ValueError as e:
+        logger.error(f"CRITICAL ERROR for combo (DS: {dataset_short_name}, M: '{worker_model_id}', P: '{prompt_version}'): {e}. This combination will not run.")
+        error_summary = {
+            "combination_details": {"dataset_short_name": dataset_short_name, "worker_model_id": worker_model_id, "prompt_version": prompt_version}, 
+            "error": f"Failed to get worker prompt: {e}", 
+            "metrics_summary": {"note": "Combination skipped due to prompt error."}
+        }
+        try:
+            with open(summary_file, "w", encoding="utf-8") as sf_combo: json.dump(error_summary, sf_combo, indent=4, ensure_ascii=False)
+            logger.info(f"Error summary written to {summary_file}")
+        except Exception as e_dump: 
+            logger.error(f"Could not write error summary file '{summary_file}': {e_dump}")
+        return
+
+    progress_bar_desc = f"{parent_desc}DS={dataset_short_name}, M={worker_model_id.split('/')[-1][:15].replace(':', '_')}, P={prompt_version}" # Also sanitize model name in desc
+    
+    futures_map = {} 
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_concurrent_items, thread_name_prefix=f"{dataset_short_name}_{safe_model_id_filename}_{prompt_version}") as executor:
+        for idx, line_content in enumerate(input_lines):
+            future = executor.submit(process_single_item_full_pipeline, 
+                                     idx + 1, line_content, worker_model_id, 
+                                     prompt_version, worker_prompt_template_str,
+                                     accuracy_judge_prompt_to_use, 
+                                     combo_skipped_log_file,
+                                     dataset_short_name
+                                     )
+            futures_map[future] = idx 
+
+        pbar = tqdm(concurrent.futures.as_completed(futures_map), total=len(input_lines), 
+                    desc=progress_bar_desc, unit="item", ncols=120, dynamic_ncols=True, leave=True, position=tqdm_position)
+
+        for future in pbar: 
+            original_idx = futures_map[future] 
+            try:
+                item_result = future.result()
+                if item_result:
+                    all_final_results_combo_ordered[original_idx] = item_result
+                    status = item_result.get("status", "UNKNOWN_ERROR")
+
+                    if status == "COMPLETED":
+                        items_fully_scored_count += 1
+                        agg_scores_combo["accuracy"].append(item_result.get("s_accuracy", 0.0))
+                        agg_scores_combo["true_integrity"].append(item_result.get("s_true_integrity", 0.0))
+                        agg_scores_combo["efficiency"].append(item_result.get("s_efficiency", 0.0))
+                        agg_scores_combo["safety"].append(item_result.get("s_safety", 0.0))
+                        agg_scores_combo["alignment_simple"].append(item_result.get("s_alignment_simple", 0.0))
+                        agg_scores_combo["esi"].append(item_result.get("esi_score", 0.0))
+                        if item_result.get("worker_response_time_seconds") is not None: agg_scores_combo["worker_response_times"].append(item_result["worker_response_time_seconds"])
+                        if item_result.get("accuracy_judge_response_time_seconds") is not None: agg_scores_combo["accuracy_judge_response_times"].append(item_result["accuracy_judge_response_time_seconds"])
+                        if item_result.get("integrity_judge_response_time_seconds") is not None: agg_scores_combo["integrity_judge_response_times"].append(item_result["integrity_judge_response_time_seconds"])
+                    
+                    if status == "ERROR_WORKER_API": api_error_counts["WORKER"] += 1
+                    elif status == "ERROR_ACCURACY_JUDGE": api_error_counts["ACCURACY_JUDGE"] += 1
+                    elif status == "ERROR_INTEGRITY_JUDGE": api_error_counts["INTEGRITY_JUDGE"] += 1
+                    elif status == "ERROR_INPUT_JSON_DECODE": processing_error_counts["INPUT_JSON_DECODE"] +=1
+                    elif status == "ERROR_UNEXPECTED_PIPELINE": processing_error_counts["UNEXPECTED_PIPELINE"] +=1
+                    elif status == "SKIPPED_DATA_INCOMPLETE": processing_error_counts["SKIPPED_DATA_INCOMPLETE"] +=1
+                    
+                    postfix_stats = {}
+                    if agg_scores_combo["esi"]: avg_esi = sum(agg_scores_combo['esi'])/len(agg_scores_combo['esi']) if agg_scores_combo['esi'] else 0; postfix_stats["AvgESI"] = f"{avg_esi:.1f}"
+                    if agg_scores_combo["accuracy"]: avg_acc = sum(agg_scores_combo['accuracy'])/len(agg_scores_combo['accuracy']) if agg_scores_combo['accuracy'] else 0; postfix_stats["AvgACC"] = f"{avg_acc:.1f}"
+                    err_counts_display = []
+                    if api_error_counts["WORKER"] > 0: err_counts_display.append(f"W.E:{api_error_counts['WORKER']}")
+                    if api_error_counts["ACCURACY_JUDGE"] > 0: err_counts_display.append(f"AJ.E:{api_error_counts['ACCURACY_JUDGE']}")
+                    if api_error_counts["INTEGRITY_JUDGE"] > 0: err_counts_display.append(f"IJ.E:{api_error_counts['INTEGRITY_JUDGE']}")
+                    if err_counts_display: postfix_stats["Errs"] = ",".join(err_counts_display)
+                    pbar.set_postfix(postfix_stats, refresh=True) 
+                else: 
+                    tqdm.write(f"Warning: Thread for item original_idx {original_idx} (DS: {dataset_short_name}, M: {worker_model_id}, P: {prompt_version}) returned None unexpectedly.")
+                    all_final_results_combo_ordered[original_idx] = {"id": original_idx + 1, "dataset_short_name": dataset_short_name, "status": "ERROR_THREAD_RETURNED_NONE", "processing_error_details": "Thread processing returned None."}
+            except Exception as exc: 
+                tqdm.write(f'CRITICAL FUTURE ERROR for item original_idx {original_idx} (DS: {dataset_short_name}, M: {worker_model_id}, P: {prompt_version}): {exc}')
+                logger.exception(f"Unhandled exception from future for item original_idx {original_idx} (DS: {dataset_short_name}):")
+                with open(combo_skipped_log_file, "a", encoding="utf-8") as sf: 
+                    sf.write(f"CRITICAL FUTURE ERROR (item original_idx {original_idx}): {exc} for DS: {dataset_short_name}, M: {worker_model_id}, P: {prompt_version}\n")
+                all_final_results_combo_ordered[original_idx] = {"id": original_idx + 1, "dataset_short_name": dataset_short_name, "status": "ERROR_FUTURE_EXCEPTION", "processing_error_details": str(exc)}
+                processing_error_counts["UNEXPECTED_PIPELINE"] +=1
+
+    all_final_results_combo_filtered = [res for res in all_final_results_combo_ordered if res is not None]
+    with open(final_output_file, "w", encoding="utf-8") as out_f:
+        for res_item in all_final_results_combo_filtered:
+            out_f.write(json.dumps(res_item, ensure_ascii=False) + "\n")
+
+    summary_header = f"\n--- Final ESI Report for: Dataset='{dataset_short_name}', Worker Model='{worker_model_id}', Prompt Version='{prompt_version}' ---"
+    print(summary_header) 
+    print(f"Final ESI results saved to: {final_output_file}")
+    total_input_items = len(input_lines)
+    print(f"Total items from input file: {total_input_items}")
+    print(f"Items for which processing was attempted (result entries created): {len(all_final_results_combo_filtered)}")
+    print(f"Items successfully scored (status COMPLETED): {items_fully_scored_count}")
+    print(f"Worker API errors: {api_error_counts['WORKER']}")
+    print(f"Accuracy Judge API/Parse errors: {api_error_counts['ACCURACY_JUDGE']}")
+    print(f"Integrity Judge API/Parse errors: {api_error_counts['INTEGRITY_JUDGE']}")
+    print(f"Input JSON Decode errors during pipeline: {processing_error_counts['INPUT_JSON_DECODE']}")
+    print(f"Skipped due to incomplete input data: {processing_error_counts['SKIPPED_DATA_INCOMPLETE']}")
+    print(f"Other unhandled pipeline errors: {processing_error_counts['UNEXPECTED_PIPELINE']}")
+
+    summary_combo_data = {
+        "combination_details": {"dataset_short_name": dataset_short_name, "worker_model_id": worker_model_id, "prompt_version": prompt_version},
+        "processing_summary": {
+            "total_input_items": total_input_items, "items_pipeline_completed_for_scoring": items_fully_scored_count,
+            "worker_api_errors": api_error_counts['WORKER'], "accuracy_judge_api_errors": api_error_counts['ACCURACY_JUDGE'],
+            "integrity_judge_api_errors": api_error_counts['INTEGRITY_JUDGE'],
+            "input_json_decode_errors_in_pipeline": processing_error_counts['INPUT_JSON_DECODE'],
+            "skipped_data_incomplete_in_pipeline": processing_error_counts['SKIPPED_DATA_INCOMPLETE'],
+            "other_unhandled_pipeline_errors": processing_error_counts['UNEXPECTED_PIPELINE'],
+        },
+        "metrics_summary": {}, "final_output_file": final_output_file,
+        "skipped_items_log": combo_skipped_log_file if os.path.exists(combo_skipped_log_file) and os.path.getsize(combo_skipped_log_file) > 0 else "None"
+    }
+    
+    # Populate metrics_summary, ensuring it exists even if no items scored
+    if items_fully_scored_count > 0:
+        for metric_key in ["accuracy", "true_integrity", "efficiency", "safety", "alignment_simple", "esi"]:
+            scores_list = agg_scores_combo.get(metric_key, []) 
+            if scores_list: 
+                avg_val = sum(scores_list) / len(scores_list)
+                summary_combo_data["metrics_summary"][f"average_{metric_key}"] = round(avg_val, 2)
+                display_name = metric_key.replace('_', ' ').title()
+                if metric_key == "accuracy":
+                    correct_count = sum(s == 100.0 for s in scores_list) 
+                    print(f"Average Accuracy (ACC) based on selected criteria: {avg_val:.2f}% ({correct_count}/{len(scores_list)})")
+                elif metric_key == "true_integrity": print(f"Average True Integrity Score: {avg_val:.2f}")
+                elif metric_key == "esi": print(f"Average ESI Score: {avg_val:.2f}")
+                else: print(f"Average {display_name}: {avg_val:.2f}")
+            else: 
+                summary_combo_data["metrics_summary"][f"average_{metric_key}"] = "N/A (no scores collected)"
+                print(f"Average {metric_key.replace('_', ' ').title()}: N/A (no scores collected)")
+    else: 
+         for metric_key in ["accuracy", "true_integrity", "efficiency", "safety", "alignment_simple", "esi"]:
+            summary_combo_data["metrics_summary"][f"average_{metric_key}"] = "N/A (0 items scored)"
+            print(f"Average {metric_key.replace('_', ' ').title()}: N/A (0 items scored)")
+
+    # Average response times separately
+    for time_key in ["worker_response_times", "accuracy_judge_response_times", "integrity_judge_response_times"]:
+        times_list = agg_scores_combo.get(time_key, [])
+        if times_list:
+            avg_time = sum(times_list) / len(times_list)
+            summary_combo_data["metrics_summary"][f"average_{time_key}_seconds"] = round(avg_time, 2)
+            print(f"Average {time_key.replace('_', ' ').title()}: {avg_time:.2f}s")
+        else:
+            summary_combo_data["metrics_summary"][f"average_{time_key}_seconds"] = "N/A"
+            print(f"Average {time_key.replace('_', ' ').title()}: N/A (no times collected)")
+            
+    if not summary_combo_data["metrics_summary"]: 
+        summary_combo_data["metrics_summary"]["note"] = "No items were successfully processed or scored for this combination."
+        if items_fully_scored_count == 0: 
+             print("No items were successfully scored in this combination.")
+
+    try:
+        with open(summary_file, "w", encoding="utf-8") as sf_combo:
+            json.dump(summary_combo_data, sf_combo, indent=4, ensure_ascii=False)
+        print(f"Summary report for this combination saved to: {summary_file}")
+    except Exception as e_dump:
+        logger.error(f"Could not write summary file '{summary_file}': {e_dump}")
+        tqdm.write(f"ERROR: Could not write summary file '{summary_file}': {e_dump}")
+    
+    if os.path.exists(combo_skipped_log_file) and os.path.getsize(combo_skipped_log_file) > 0 :
+        print(f"Note: Some items were skipped or had errors during processing for this combination. Details in: {combo_skipped_log_file}")
+    print("-" * 70 + "\n")
+
+
+def main():
+    logger.info(f"Starting Concurrent Pipeline Evaluation Framework...")
+    
+    worker_models = APP_CONFIG.WORKER_MODEL_IDS
+    prompt_versions = APP_CONFIG.PROMPT_VERSIONS_TO_TEST
+    datasets_to_evaluate_short_names = APP_CONFIG.DATASETS_TO_RUN
+
+    if not worker_models or not prompt_versions :
+        logger.error("No worker models or prompt versions specified in settings. Exiting.")
+        return
+    if not datasets_to_evaluate_short_names:
+        logger.error("No datasets specified in DATASETS_TO_RUN in settings. Exiting.")
+        return
+        
+    print(f"\nFound {len(worker_models)} worker models: {worker_models}")
+    print(f"Found {len(prompt_versions)} prompt versions: {prompt_versions}")
+    print(f"Configured to run on {len(datasets_to_evaluate_short_names)} dataset(s): {datasets_to_evaluate_short_names}")
+    
+    total_overall_combinations = len(datasets_to_evaluate_short_names) * len(worker_models) * len(prompt_versions)
+    print(f"Total evaluation combinations to run: {total_overall_combinations}")
+    
+    if total_overall_combinations == 0:
+        logger.error("Calculated 0 total combinations. Check WORKER_MODEL_IDS, PROMPT_VERSIONS_TO_TEST, and DATASETS_TO_RUN in settings. Exiting.")
+        return
+    print("-" * 70)
+
+    overall_start_time = time.time()
+    overall_combo_idx = 0 
+    
+    max_concurrent_items_per_combo = getattr(APP_CONFIG, "MAX_CONCURRENT_ITEMS_PER_COMBO", 5) 
+
+    for ds_short_name in datasets_to_evaluate_short_names:
+        dataset_config = APP_CONFIG.DATASET_CONFIGS.get(ds_short_name)
+        if not dataset_config or "path" not in dataset_config:
+            logger.error(f"Configuration for dataset '{ds_short_name}' is missing or invalid in DATASET_CONFIGS. Skipping this dataset.")
+            continue
+        
+        input_file_path = dataset_config["path"]
+        logger.info(f"\nProcessing Dataset: '{ds_short_name}' from file: '{input_file_path}'")
+
+        try:
+            with open(input_file_path, "r", encoding="utf-8") as f_in:
+                input_lines_for_dataset = f_in.readlines()
+                if not input_lines_for_dataset:
+                    logger.warning(f"Input file '{input_file_path}' for dataset '{ds_short_name}' is empty. Skipping this dataset.")
+                    continue
+        except FileNotFoundError:
+            logger.error(f"Input file '{input_file_path}' for dataset '{ds_short_name}' not found. Skipping this dataset.")
+            continue
+        except Exception as e:
+            logger.error(f"Error reading input file '{input_file_path}' for dataset '{ds_short_name}': {e}. Skipping this dataset.")
+            continue
+        
+        try:
+            # Get the ACCURACY judge prompt specific to this dataset type
+            # Pass the short name to the prompt selector function
+            selected_accuracy_judge_prompt_str = get_accuracy_judge_prompt_template_for_dataset(ds_short_name)
+            logger.info(f"Using ACCURACY judge prompt type suitable for: {ds_short_name}")
+        except Exception as e:
+            logger.error(f"Could not determine accuracy judge prompt for dataset '{ds_short_name}': {e}. Skipping this dataset.")
+            continue
+
+        for model_id in worker_models:
+            for prompt_ver in prompt_versions:
+                overall_combo_idx += 1
+                parent_description_text = f"Overall {overall_combo_idx}/{total_overall_combinations}| "
+                
+                logger.info(f"Starting evaluation for: Dataset='{ds_short_name}', Model='{model_id}', Prompt='{prompt_ver}' (Max concurrent items: {max_concurrent_items_per_combo})")
+                run_evaluation_for_combination(
+                    dataset_short_name=ds_short_name,
+                    input_lines=input_lines_for_dataset,
+                    worker_model_id=model_id, 
+                    prompt_version=prompt_ver, 
+                    final_output_filename_template=APP_CONFIG.FINAL_OUTPUT_FILE_TEMPLATE,
+                    skipped_log_filename_template=APP_CONFIG.SKIPPED_FILE_LOG_TEMPLATE, 
+                    summary_filename_template=APP_CONFIG.SUMMARY_FILE_TEMPLATE,
+                    accuracy_judge_prompt_to_use=selected_accuracy_judge_prompt_str, 
+                    tqdm_position=0, 
+                    parent_desc=parent_description_text,
+                    max_concurrent_items=max_concurrent_items_per_combo
+                )
+    
+    overall_end_time = time.time()
+    total_duration_seconds = overall_end_time - overall_start_time
+    print(f"\nAll {total_overall_combinations} configured evaluations (across all selected datasets) have been completed.")
+    print(f"Total execution time: {total_duration_seconds:.2f} seconds ({time.strftime('%H:%M:%S', time.gmtime(total_duration_seconds))}).")
+
+if __name__ == "__main__":
+    main()

prompts.py

@@ -0,0 +1,181 @@
+# prompts.py
+import os 
+
+PROMPT_DIRECT_ANSWER_TEMPLATE = (
+    "Based on the 'Background Information (Instruction)' and 'Specific Question (Question)' below, "
+    "provide the most direct and concise answer. "
+    "The answer must be strictly derived from the provided information ONLY. "
+    "It should be a single word, a short phrase, a specific name, a numerical value, a code snippet, or a status description that directly addresses the core of the question. "
+    "Do NOT include any explanations, justifications, prefixes (e.g., 'The answer is:'), suffixes, conversational filler, or any information not explicitly stated in the 'Background Information'. "
+    "Output only the precise answer itself.\n\n"
+    "Background Information (Instruction):\n{instruction}\n\n"
+    "Specific Question (Question):\n{question}\n\n"
+    "Answer:"
+)
+
+PROMPT_COT_ANSWER_TEMPLATE = (
+    "Your task is to answer the 'Specific Question (Question)' based on the 'Background Information (Instruction)'.\n"
+    "Follow these steps:\n"
+    "1. First, carefully analyze the Instruction and the Question.\n"
+    "2. Provide a step-by-step reasoning process that shows how you arrive at the answer. Start this section with 'Reasoning:'.\n"
+    "3. After your reasoning, on a new line, provide the final, direct, and concise answer. This final answer MUST be prefixed with 'Final Answer: ' (note the space after the colon).\n"
+    "The final answer part should be a single word, a short phrase, a specific name, a numerical value, a code snippet, or a status description, derived ONLY from the 'Background Information'.\n"
+    "Do not add any other explanations or text after the 'Final Answer: ' prefix and the answer itself.\n\n"
+    "Background Information (Instruction):\n{instruction}\n\n"
+    "Specific Question (Question):\n{question}\n\n"
+)
+
+PROMPT_EXPERT_ANSWER_TEMPLATE = (
+    "Leveraging your expertise in lunar exploration engineering, analyze the 'Background Information (Instruction)' and 'Specific Question (Question)' below. "
+    "Provide the most direct, concise, and factually accurate answer based SOLELY on the information presented. "
+    "Your response should be a single word, a short phrase, a specific name, a numerical value, a code snippet, or a status description that precisely answers the question. "
+    "Do NOT include any explanations, justifications, prefixes (e.g., 'The answer is:'), suffixes, conversational filler, or any information not explicitly stated in the 'Background Information'. "
+    "Output only the precise answer itself.\n\n"
+    "Background Information (Instruction):\n{instruction}\n\n"
+    "Specific Question (Question):\n{question}\n\n"
+    "Answer:"
+)
+
+def get_worker_prompt_template(prompt_version_name: str) -> str:
+    if prompt_version_name == "DIRECT":
+        return PROMPT_DIRECT_ANSWER_TEMPLATE
+    elif prompt_version_name == "COT":
+        return PROMPT_COT_ANSWER_TEMPLATE
+    elif prompt_version_name == "EXPERT":
+        return PROMPT_EXPERT_ANSWER_TEMPLATE
+    else:
+        raise ValueError(f"Unknown PROMPT_VERSION '{prompt_version_name}'. Available: DIRECT, COT, EXPERT.")
+
+# --- ACCURACY JUDGE PROMPTS (Context-Dependent) ---
+
+# For L1:  (Reasonable Inference Path, Result Approximately Correct)
+PROMPT_FOR_JUDGE_L1_ACCURACY_TEMPLATE = (
+    "You are an AI Evaluator. Your task is to determine if the 'Candidate Answer' is **approximately correct and seems to follow a reasonable line of thought (if a thought process is apparent)** in response to the 'Question', considering the 'Instruction'. Minor inaccuracies or stylistic differences from the 'Reference Answer' are acceptable if the core understanding and the final conclusion are generally sound and not fundamentally flawed.\n\n"
+    "**Evaluation Focus: Approximate Correctness & Plausibility of Approach**\n"
+    "The Candidate Answer does NOT need to be a perfect match to the Reference Answer. The Reference is just one example of a correct answer. The answer should demonstrate a basic, reasonable attempt to address the question based on the provided context.\n\n"
+    "Consider the Candidate Answer **'is_judged_correct': true** if:\n"
+    "1.  **Addresses Core Question:** The answer makes a clear attempt to address the main point or intent of the Question.\n"
+    "2.  **Reasonable (Implicit or Explicit) Path:** \n"
+    "    - If reasoning steps are provided (e.g., in a CoT prompt's raw output, which you might infer from the candidate answer if it's complex), these steps should generally make sense and not contain glaring logical fallacies that completely invalidate the answer.\n"
+    "    - For direct answers, the answer itself should appear as a plausible or logical outcome derived from a reasonable interpretation of the instruction and question. It shouldn't feel random or completely disconnected from a sensible thought process.\n"
+    "3.  **Result Approximately Correct:** The key factual elements or the main conclusion of the Candidate Answer are mostly correct, or at least not fundamentally wrong or severely misleading in the context of the Instruction. Small errors on peripheral details can be tolerated if the main thrust of the answer is acceptable and points in the right direction.\n"
+    "4.  **Not Wildly Off-Topic or Critically Misleading:** The answer is relevant to the question and does not introduce information that is critically misleading or makes the answer dangerous.\n\n"
+    "Mark as **'is_judged_correct': false** if:\n"
+    "- The answer is based on a completely flawed understanding or an unreasonable/illogical thought process (if discernible).\n"
+    "- The final result/conclusion is fundamentally incorrect or significantly misleading regarding the core of the Question.\n"
+    "- The answer is entirely irrelevant to the question or provides no substantive response to its core.\n"
+    "- The answer misses the core point of the question by a very wide margin, indicating a lack of basic comprehension or reasonable inference.\n\n"
+    "**Be lenient on phrasing, minor omissions, and slight factual inaccuracies on non-critical details. The primary concern is whether a reasonable thought process (even if simple for direct answers) could lead to an answer that is approximately correct in its main assertion.** It should be more than just 'touching a keyword' but doesn't need to be perfect.\n\n"
+    "Here is the information you need to evaluate:\n"
+    "1. Instruction (Original Context):\n```\n{instruction}\n```\n\n"
+    "2. Question (Original Question):\n```\n{question}\n```\n\n"
+    "3. Reference Answer (One example of a correct answer; do not require strict matching. Use it as a guide for what a good answer *could* look like.):\n```\n{reference_answer}\n```\n\n"
+    "4. Candidate Answer (The AI's response to evaluate):\n```\n{candidate_answer}\n```\n\n"
+    "**Output Format:**\n"
+    "Please respond **ONLY** with a JSON object containing two keys:\n"
+    "1. `\"is_judged_correct\"`: A boolean value (true if the Candidate Answer is approximately correct and based on a reasonable approach, false otherwise).\n"
+    "2. `\"reasoning\"`: A brief explanation for your decision, commenting on the plausibility of the approach and the approximate correctness of the result.\n\n"
+    "Now, provide your evaluation based on these L1 criteria (reasonable inference path, approximately correct result):"
+)
+
+# For L2: (Relatively Lenient - Sensibly Correct, More than Just Vaguely Related)
+PROMPT_FOR_JUDGE_L2_ACCURACY_TEMPLATE = (
+    "You are an AI Evaluator with a **relatively lenient but fair** stance. Your task is to determine if the 'Candidate Answer' is **sensibly correct and directly relevant** to the 'Question', based on the 'Instruction' and 'Reference Answer'. The answer must be more than just vaguely related; it should be a valid, even if imperfect or incomplete, response to the question's main intent. Do not require perfect alignment with the 'Reference Answer'.\n\n"
+    "**Evaluation Focus: Sensible Correctness & Direct Relevance to Core Question**\n\n"
+    "Consider the Candidate Answer **'is_judged_correct': true** if:\n"
+    "1.  **Directly Addresses Core Question:** The answer clearly makes a direct attempt to respond to the primary query or intent of the 'Question'.\n"
+    "2.  **Core Information is Sound:** The essential factual information or the main conclusion presented in the answer, as it relates to the core question, is correct and consistent with the 'Instruction'.\n"
+    "3.  **Relevant and On-Topic:** The answer is primarily focused on the question and does not consist mostly of irrelevant information. It shouldn't just touch a keyword and then go off-topic.\n"
+    "4.  **No Significant Misinformation on Core Topic:** The answer does not contain major factual errors or severely misleading statements that would invalidate its usefulness as an answer to the Question's core.\n"
+    "5.  Omissions of some details or stylistic differences from the 'Reference Answer' are acceptable if the core of the Candidate Answer is sound and relevant to the question's main point.\n\n"
+    "Mark as **'is_judged_correct': false** if:\n"
+    "- The answer is largely irrelevant or only tangentially related to the Question's core intent (i.e., 'just touching upon a keyword' without substantively addressing the question is not enough).\n"
+    "- The core factual claim of the answer, essential to the question, is clearly incorrect or contradicts the 'Instruction'.\n"
+    "- The answer, while possibly containing some correct elements, is overall misleading or fails to address the question's primary intent in a meaningful way.\n\n"
+    "**The answer needs to be a reasonable and direct attempt at answering the question's main point correctly, not just a fleeting mention of related terms. Give the benefit of the doubt for minor issues if the core is addressed.**\n\n"
+    "Here is the information you need to evaluate:\n"
+    "1. Instruction (Original Context):\n```\n{instruction}\n```\n\n"
+    "2. Question (Original Question):\n```\n{question}\n```\n\n"
+    "3. Reference Answer (A guide to a correct answer; strict matching is not required. Focus on the candidate's response to the question based on the instruction.):\n```\n{reference_answer}\n```\n\n"
+    "4. Candidate Answer (The AI's response to evaluate):\n```\n{candidate_answer}\n```\n\n"
+    "**Output Format:**\n"
+    "Please respond **ONLY** with a JSON object containing two keys:\n"
+    "1. `\"is_judged_correct\"`: A boolean value (true if the Candidate Answer is sensibly correct and directly relevant by these relatively lenient standards, false otherwise).\n"
+    "2. `\"reasoning\"`: A brief explanation for your decision.\n\n"
+    "Now, provide your evaluation based on these L2 criteria (sensibly correct, directly relevant, relatively lenient):"
+)
+
+# For L3: (Relatively Strict - Result Largely Consistent)
+PROMPT_FOR_JUDGE_L3_ACCURACY_TEMPLATE = (
+    "You are a discerning AI Evaluator. Your task is to determine if the 'Candidate Answer' is **largely consistent with the expected correct information and factually sound**, accurately addressing the 'Question' based on the 'Instruction'. While not requiring a verbatim match to the 'Reference Answer', a significant overlap in key facts and meaning is expected. The answer should be substantially correct.\n\n"
+    "**Evaluation Focus: Substantial Factual Alignment, Core Consistency, and Accuracy**\n\n"
+    "Consider the Candidate Answer **'is_judged_correct': true** if:\n"
+    "1.  **Core Factual Alignment:** The primary facts, figures, entities, or conclusions presented in the Candidate Answer align substantially and correctly with those derivable from the 'Instruction' and reflected as correct by the 'Reference Answer' (if reliable).\n"
+    "2.  **Addresses Key Aspects of Question Accurately:** The answer covers the most important aspects of the 'Question' with factual accuracy.\n"
+    "3.  **No Major Factual Discrepancies or Logical Flaws:** There are no significant factual contradictions with the 'Instruction'. If reasoning is implied or shown, it should be sound.\n"
+    "4.  **Meaningful Overlap with Correct Information:** The Candidate Answer, in its essence, conveys a meaning and set of critical information that is largely the same as a known correct answer. Minor differences in detail or phrasing are acceptable if they don't alter the core factual correctness.\n\n"
+    "Consider the Candidate Answer **'is_judged_correct': false** if:\n"
+    "- It presents key facts or conclusions that are demonstrably incorrect or significantly different from the truth established by the 'Instruction' or a reliable 'Reference Answer'.\n"
+    "- It omits a majority of the critical information required to correctly and substantially answer the Question.\n"
+    "- It provides an answer that, while possibly touching on the topic, fundamentally misses or misrepresents the core information expected for a largely correct answer.\n"
+    "- It contains logical flaws that undermine the validity of its conclusion regarding the question.\n\n"
+    "**The emphasis is on whether the candidate answer captures the bulk of the correct information accurately and is factually sound.**\n\n"
+    "Here is the information you need to evaluate:\n"
+    "1. Instruction (Original Context):\n```\n{instruction}\n```\n\n"
+    "2. Question (Original Question):\n```\n{question}\n```\n\n"
+    "3. Reference Answer (A strong benchmark for a correct and comprehensive answer. Candidate should largely align with its core facts.):\n```\n{reference_answer}\n```\n\n"
+    "4. Candidate Answer (The AI's response to evaluate):\n```\n{candidate_answer}\n```\n\n"
+    "**Output Format:**\n"
+    "Please respond **ONLY** with a JSON object containing two keys:\n"
+    "1. `\"is_judged_correct\"`: A boolean value (true if the Candidate Answer is largely consistent with the core correct information and factually sound, false otherwise).\n"
+    "2. `\"reasoning\"`: A brief explanation, highlighting key consistencies or discrepancies regarding factual content.\n\n"
+    "Now, provide your evaluation based on these L3 criteria (largely consistent and factually sound result):"
+)
+
+
+def get_accuracy_judge_prompt_template_for_dataset(dataset_short_name: str) -> str:
+    """Selects the appropriate ACCURACY judge prompt based on the dataset short name."""
+    name_lower = dataset_short_name.lower() 
+    if "l1" in name_lower: 
+        print(f"INFO: Using L1 ACCURACY judge prompt for dataset '{dataset_short_name}'. (Reasonable Path, Approx. Correct Result)")
+        return PROMPT_FOR_JUDGE_L1_ACCURACY_TEMPLATE
+    elif "l2" in name_lower:
+        print(f"INFO: Using L2 ACCURACY judge prompt for dataset '{dataset_short_name}'. (Sensibly Correct, More than Just Related)")
+        return PROMPT_FOR_JUDGE_L2_ACCURACY_TEMPLATE
+    elif "l3" in name_lower:
+        print(f"INFO: Using L3 ACCURACY judge prompt for dataset '{dataset_short_name}'. (Largely Consistent Result)")
+        return PROMPT_FOR_JUDGE_L3_ACCURACY_TEMPLATE
+    else:
+        # Default to L2 (balanced) if no specific L1/L3 match for the short name (e.g. for "Demo")
+        print(f"WARNING: Dataset short name '{dataset_short_name}' does not match L1, L2, or L3 patterns. Defaulting to L2 ACCURACY judge prompt.")
+        return PROMPT_FOR_JUDGE_L2_ACCURACY_TEMPLATE 
+
+PROMPT_FOR_JUDGE_LLM_TRUE_INTEGRITY_TEMPLATE = (
+    "You are a meticulous AI Evaluator focusing on the **completeness and logical integrity** of an AI assistant's thought process and output. Your task is to assess if the AI assistant has thoroughly considered all relevant aspects of the 'Instruction' and 'Question' to arrive at its 'Candidate Output'.\n\n"
+    "**Evaluation Focus: Process Integrity & Completeness**\n"
+    "1.  **Condition Coverage:** Did the AI's output (including any reasoning steps if visible) explicitly or implicitly address all critical conditions, constraints, and pieces of information provided in the 'Instruction' and 'Question'?\n"
+    "2.  **Question Comprehension:** Does the output demonstrate a full understanding of all parts of the 'Question'? Or does it only focus on a subset?\n"
+    "3.  **Information Utilization:** Was relevant information from the 'Instruction' appropriately used in the reasoning or to formulate the answer? Were any crucial pieces of provided information ignored?\n"
+    "4.  **Logical Flow (if reasoning is present):** If a thought process or reasoning steps are visible in the 'Candidate Output (Raw)', are these steps logical, coherent, and without significant gaps or unjustified leaps?\n"
+    "5.  **Completeness of Answer relative to Question:** Even if the final cleaned answer is brief, does the overall output (raw or cleaned, as appropriate) suggest that the AI *considered* what was necessary to answer comprehensively?\n\n"
+    "**Do NOT focus on whether the final answer is correct in this evaluation (that is handled separately). Focus on the *process and completeness of consideration*.**\n\n"
+    "Here is the information you need to evaluate:\n"
+    "1. Instruction (Original Context):\n```\n{instruction}\n```\n\n"
+    "2. Question (Original Question):\n```\n{question}\n```\n\n"
+    "3. Candidate Output (Raw - this may include reasoning steps if provided by the worker AI):\n```\n{candidate_output_raw}\n```\n\n"
+    "4. Candidate Answer (Cleaned - the final concise answer extracted from the raw output):\n```\n{candidate_answer_cleaned}\n```\n\n"
+    "**Output Format:**\n"
+    "Please respond **ONLY** with a JSON object containing two keys:\n"
+    "1. `\"integrity_score\"`: A numerical score from 0 to 100, where:\n"
+    "   - 0-30: Severely lacking integrity; missed most critical conditions or showed flawed reasoning.\n"
+    "   - 31-60: Partially addressed conditions/question parts; some notable omissions or minor logical gaps.\n"
+    "   - 61-90: Mostly complete; addressed most key aspects well with minor room for improvement in thoroughness.\n"
+    "   - 91-100: Excellent integrity; comprehensively considered all relevant conditions and parts of the question with clear, sound reasoning (if visible).\n"
+    "2. `\"integrity_reasoning\"`: A brief explanation for the assigned integrity_score, highlighting key observations about condition coverage, information use, or logical flow.\n\n"
+    "Example JSON response:\n"
+    "{{\n"
+    "  \"integrity_score\": 85,\n"
+    "  \"integrity_reasoning\": \"The AI considered most conditions from the instruction but did not explicitly address the time constraint mentioned in the question.\"\n"
+    "}}\n\n"
+    "Now, provide your evaluation for the given data in the specified JSON format only:"
+)

settings.json

@@ -0,0 +1,81 @@
+{
+    "_comment_OpenRouter_Global_Settings": "Global settings if using OpenRouter for any LLM. Worker LLM will use these.",
+    "OPENROUTER_API_BASE_URL": "https://openrouter.ai/api/v1",
+    "OPENROUTER_API_KEY": "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",
+    "OPENROUTER_HTTP_REFERER": "YOUR_SITE_URL_OR_PROJECT_NAME_HERE",
+    "OPENROUTER_X_TITLE": "Lunar-Bench-Evaluation",
+
+    "_comment_Worker_LLM_Settings": "Settings for Worker LLMs",
+    "WORKER_API_URL": "https://openrouter.ai/api/v1/chat/completions",
+    "WORKER_API_TOKEN": "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", 
+    "WORKER_MODEL_IDS": [
+            "openai/gpt-4o","openai/gpt-4.1-mini"
+    ],
+
+    "_comment_Judge_Settings": "Settings for Judge LLMs",
+    "ACCURACY_JUDGE_API_URL": "https://api.deepseek.com/v1/chat/completions",
+    "ACCURACY_JUDGE_API_TOKEN": "sk-655b57b988684fb096d57501204f1ef7",
+    "ACCURACY_JUDGE_MODEL_ID": "deepseek-chat",
+
+    "INTEGRITY_JUDGE_API_URL": "https://api.deepseek.com/v1/chat/completions",
+    "INTEGRITY_JUDGE_API_TOKEN": "sk-655b57b988684fb096d57501204f1ef7",
+    "INTEGRITY_JUDGE_MODEL_ID": "deepseek-chat",
+
+    "_comment_Dataset_Configuration": "Define datasets and select which ones to run",
+    "DATASET_CONFIGS": {
+        "L1": {
+            "path": "./Data Demo/L1-1K.jsonl",
+            "description": "Dataset L1-1K, expects lenient ACC judgment."
+        },
+        "L2": {
+            "path": "./Data Demo/L2-1K.jsonl",
+            "description": "Dataset L2-1K, expects balanced ACC judgment."
+        },
+        "L3": {
+            "path": "./Data Demo/L3-1K.jsonl",
+            "description": "Dataset L3-1K, expects stricter, logical ACC judgment."
+        }
+    },
+    "DATASETS_TO_RUN": ["L1", "L2", "L3"], 
+
+    "_comment_File_Paths_Templates": "File path templates use {dataset_short_name}, {model_id}, {prompt_version}",
+    "WORKER_OUTPUT_FILE_TEMPLATE": "./Intermediate/WorkerOutput_{dataset_short_name}_{model_id}_{prompt_version}.jsonl",
+    "FINAL_OUTPUT_FILE_TEMPLATE": "./Result/ESI_Result_{dataset_short_name}_{model_id}_{prompt_version}.jsonl",
+    "SKIPPED_FILE_LOG_TEMPLATE": "./Result/Skipped_Log_{dataset_short_name}_{model_id}_{prompt_version}.txt",
+    "SUMMARY_FILE_TEMPLATE": "./Result/Summary_{dataset_short_name}_{model_id}_{prompt_version}.json",
+
+    "_comment_Worker_LLM_Prompts": "Worker LLM Prompt Configuration",
+    "PROMPT_VERSIONS_TO_TEST": [
+        "DIRECT"
+    ],
+
+    "_comment_Metric_Notes": "Notes on specific metrics",
+    "_comment_Accuracy_Note": "ACC (Accuracy) judgment varies by dataset type (L1, L2, L3).",
+    "_comment_Integrity_Note": "TRUE_INTEGRITY means 'process completeness and condition coverage'.",
+
+    "_comment_Efficiency_Params": "Efficiency (S_eff) Parameters",
+    "TOKEN_BUDGET_EFFICIENCY": 8000,
+    "P_IRRELEVANT_EFFICIENCY": 0.0,
+
+    "_comment_Safety_Params": "Safety (S_safety) Parameters",
+    "SAFETY_SEVERE_KEYWORDS": "unsafe_example,another_keyword",
+
+    "_comment_Alignment_Simplified_Params": "Simplified Alignment (S_align_simple) Parameters",
+    "ALIGNMENT_LENGTH_MISMATCH_PENALTY": 10,
+    "ALIGNMENT_MAX_LENGTH_RATIO_VS_REF": 3.0,
+
+    "_comment_ESI_Weights": "ESI Score Weights. These will be normalized if their sum is not 1.0.",
+    "WEIGHT_ACCURACY": 0.30,
+    "WEIGHT_TRUE_INTEGRITY": 0.25,
+    "WEIGHT_EFFICIENCY": 0.15,
+    "WEIGHT_SAFETY": 0.15,
+    "WEIGHT_ALIGNMENT_SIMPLE": 0.15,
+
+    "_comment_Global_API_Call_Settings": "Global API Call Settings (Retries, Delays, Timeout)",
+    "MAX_RETRIES": 3,
+    "RETRY_DELAY_SECONDS": 10,
+    "REQUEST_TIMEOUT_SECONDS": 180,
+
+    "_comment_Concurrency_Settings": "Settings for concurrent item processing within a combination",
+    "MAX_CONCURRENT_ITEMS_PER_COMBO": 5
+}

utils.py

@@ -0,0 +1,48 @@
+# utils.py
+import re
+
+def clean_worker_model_answer(raw_answer_text: str, prompt_version: str) -> tuple[str, bool]:
+    """
+    Cleans the raw answer text from the worker LLM.
+    Returns:
+        - cleaned_answer (str)
+        - is_correctly_formatted_output (bool): True if CoT format was followed (if CoT was used), True for other prompt types by default.
+    """
+    answer = raw_answer_text.strip()
+    is_correctly_formatted_output = True 
+
+    if prompt_version == "COT":
+        match = re.search(r"Final Answer:\s*(.*)", answer, re.IGNORECASE | re.DOTALL)
+        if match:
+            answer = match.group(1).strip()
+        else:
+            is_correctly_formatted_output = False 
+            # Using print for this specific info as it's about an expected format from the worker
+            print(f"\nINFO (Worker Output): COT prompt used, but 'Final Answer:' marker not found. Cleaning applied to full raw output. Raw Preview: \"{raw_answer_text[:100]}...\"")
+    
+    prefixes_to_remove = [
+        "Answer is:", "Answer:", "The answer is:", "The final answer is ", "Expert Answer:",
+        "答案是：", "答案：", "答案是", "答案", "好的，答案是：", "好的，答案是", "了解，答案是：", "了解，答案是" # Retained for robustness
+    ] 
+    
+    temp_answer = answer 
+    for prefix in prefixes_to_remove:
+        if temp_answer.lower().startswith(prefix.lower()):
+            temp_answer = temp_answer[len(prefix):].strip()
+            break 
+    answer = temp_answer 
+
+    if answer.startswith("- "): answer = answer[2:].strip()
+    if answer.startswith("* "): answer = answer[2:].strip()
+    
+    if len(answer) > 1 and ((answer.startswith('"') and answer.endswith('"')) or \
+                           (answer.startswith("'") and answer.endswith("'"))):
+        answer = answer[1:-1]
+
+    if len(answer) > 1 and (answer.endswith(".") or answer.endswith("。")): # Handles English and Chinese periods
+         answer = answer[:-1].strip()
+            
+    if answer.startswith("> "): answer = answer[2:].strip()
+    if answer.startswith(">"): answer = answer[1:].strip()
+        
+    return answer.strip(), is_correctly_formatted_output