synapse-hub 2.2.2 → 2.2.4

package/tools/distill_log.py

@@ -26,8 +26,10 @@ def distill(log_text, max_lines=40):
     # Noise filters
     noise_patterns = [
         re.compile(r'^\s*$'),
-        re.compile(r'\[INFO\b'),
-        re.compile(r'\[DEBUG\b'),
+        re.compile(r'\[INFO\b|\bINFO:|\bINFO\s+', re.IGNORECASE),
+        re.compile(r'\[DEBUG\b|\bDEBUG:|\bDEBUG\s+', re.IGNORECASE),
+        re.compile(r'\[TRACE\b|\bTRACE:|\bTRACE\s+', re.IGNORECASE),
+        re.compile(r'^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}.*\b(?:INFO|DEBUG|TRACE)\b', re.IGNORECASE),
         re.compile(r'\bPASSED\b', re.IGNORECASE),
         re.compile(r'> Task :'),
         re.compile(r'SLF4J:'),
@@ -47,10 +49,11 @@ def distill(log_text, max_lines=40):
         re.compile(r'Caused by:'),
         re.compile(r'at (?:Enterprise\.|Script\d+|com\.kms)'),
         re.compile(r'TC-\d+.*FAILED'),
+        re.compile(r'FAIL\s+.*(?:\.spec|\.test)'),
     ]
 
-    tc_pattern = re.compile(r'(TC-\d+)')
-    line_num_pattern = re.compile(r'((?:Script\d+|\w+Page)\.groovy:(\d+))')
+    tc_pattern = re.compile(r'(TC-\d+|test_[A-Za-z0-9_]+|[A-Za-z0-9_-]+\.(?:spec|test)\.[jt]sx?)')
+    line_num_pattern = re.compile(r'((?:Script\d+|\w+Page|\w+\.(?:groovy|ts|js|py)):(\d+))|File "([^"]+)", line (\d+)')
     exception_pattern = re.compile(r'([A-Za-z0-9_.]*(?:Exception|Error)):?\s*(.*)')
 
     captured_failures = []
@@ -63,7 +66,7 @@ def distill(log_text, max_lines=40):
     for line in lines:
         # Check if line indicates failure
         is_fail_line = any(p.search(line) for p in failure_indicators)
-        is_noise = any(p.search(line) for p in noise_patterns)
+        is_noise = any(p.search(line) for p in noise_patterns) and not is_fail_line
 
         # Detect TC identifier
         m_tc = tc_pattern.search(line)
@@ -73,7 +76,7 @@ def distill(log_text, max_lines=40):
         # Detect script line number
         m_loc = line_num_pattern.search(line)
         if m_loc:
-            failing_locs.append(m_loc.group(1))
+            failing_locs.append(m_loc.group(1) or f"{m_loc.group(3)}:{m_loc.group(4)}")
 
         if is_fail_line:
             in_failure_block = True
@@ -102,9 +105,12 @@ def distill(log_text, max_lines=40):
         output.append("======================================================================")
         return "\n".join(output)
 
-    output.append(f"❌ FAILURES DETECTED: {len(failing_tcs)} Test Case(s) marked FAILED.")
     if failing_tcs:
+        output.append(f"❌ FAILURES DETECTED: {len(failing_tcs)} Test Case(s) marked FAILED.")
         output.append(f"   Targeted TCs: {', '.join(sorted(failing_tcs))}")
+    else:
+        output.append(f"❌ FAILURES / ERRORS DETECTED: {len(captured_failures)} failure block(s) isolated.")
+        
     if failing_locs:
         unique_locs = sorted(set(failing_locs))
         output.append(f"   Failing Script Location(s): {', '.join(unique_locs[:5])}")
@@ -116,10 +122,13 @@ def distill(log_text, max_lines=40):
     output.append("======================================================================")
     return "\n".join(output)
 
+# Public alias for MCP server compatibility
+distill_log_content = distill
+
 def main():
     parser = argparse.ArgumentParser(description="Distill terminal execution logs into high-signal failure blocks.")
     parser.add_argument("--file", "-f", help="Path to raw log file (reads from stdin if omitted).")
-    parser.add_argument("--save-raw", "-s", default="Reports/raw_execution.log", help="Path to preserve raw log.")
+    parser.add_argument("--save-raw", "-s", default=None, help="Path to preserve raw log (omitted by default to prevent hub pollution).")
     args = parser.parse_args()
 
     if args.file:
@@ -134,13 +143,13 @@ def main():
             sys.exit(0)
         log_text = sys.stdin.read()
 
-    # Preserve raw log on disk
+    # Preserve raw log on disk if explicitly requested
     if args.save_raw:
         try:
             os.makedirs(os.path.dirname(os.path.abspath(args.save_raw)), exist_ok=True)
             with open(args.save_raw, "w", encoding="utf-8") as fp:
                 fp.write(log_text)
-        except Exception as e:
+        except Exception:
             pass
 
     summary = distill(log_text)

package/tools/export_postman_collection.py

@@ -36,6 +36,7 @@ Usage:
 import os
 import sys
 import json
+import re
 import uuid
 import csv
 import argparse
@@ -82,7 +83,7 @@ def build_test_script(
         "// Auto-generated Test Assertions by Synapse-Hub",
         f"// 1. Assert Status Code is {expected_status}",
         f"pm.test('Status code is {expected_status}', function () {{",
-        f"    pm.expect(pm.response.code).to.be.oneOf([{expected_status}, 200, 201]);",
+        f"    pm.expect(pm.response.code).to.eql({expected_status});",
         "});",
         "",
         f"// 2. Assert SLA Latency (< {max_time_ms}ms)",
@@ -280,13 +281,34 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
                         "options": {"raw": {"language": "json"}}
                     }
 
-            # URL decomposition
-            path_segments = [seg for seg in path.strip("/").split("/") if seg]
+            # URL decomposition and path parameterization
+            raw_path = path
+            path_variables = []
+            normalized_segments = []
+            for seg in path.strip("/").split("/"):
+                if not seg:
+                    continue
+                match = re.match(r"^\{([a-zA-Z0-9_-]+)\}$", seg)
+                if match:
+                    param_name = match.group(1)
+                    raw_path = raw_path.replace(f"{{{param_name}}}", f":{param_name}")
+                    normalized_segments.append(f":{param_name}")
+                    default_val = "{{lastCreatedId}}" if param_name.lower() in ("id", "entityid", "orderid") else f"{{{{{param_name}}}}}"
+                    path_variables.append({
+                        "key": param_name,
+                        "value": default_val,
+                        "description": f"URL Path variable {param_name}"
+                    })
+                else:
+                    normalized_segments.append(seg)
+
             url_obj = {
-                "raw": f"{{{{baseUrl}}}}{path}",
+                "raw": f"{{{{baseUrl}}}}{raw_path}",
                 "host": ["{{baseUrl}}"],
-                "path": path_segments
+                "path": normalized_segments
             }
+            if path_variables:
+                url_obj["variable"] = path_variables
             if query_params:
                 url_obj["query"] = query_params
 
@@ -451,10 +473,10 @@ def generate_postman_environment(name: str = "Enterprise-Staging-Env", base_url:
         "name": name,
         "values": [
             {"key": "baseUrl", "value": base_url, "enabled": True},
-            {"key": "bearerToken", "value": "", "enabled": True},
+            {"key": "bearerToken", "value": "", "type": "secret", "enabled": True},
             {"key": "lastCreatedId", "value": "1", "enabled": True},
             {"key": "adminUser", "value": "qa_admin@enterprise.local", "enabled": True},
-            {"key": "adminPass", "value": "SecretVault#2026", "enabled": True}
+            {"key": "adminPass", "value": "SecretVault#2026", "type": "secret", "enabled": True}
         ],
         "_postman_variable_scope": "environment"
     }

package/tools/generate_jmx_plan.py

@@ -122,6 +122,16 @@ def build_jmx_xml(
         f'            <stringProp name="Argument.value">{sla_p95}</stringProp>',
         '            <stringProp name="Argument.metadata">=</stringProp>',
         '          </elementProp>',
+        '          <elementProp name="MAX_LATENCY" elementType="Argument">',
+        '            <stringProp name="Argument.name">MAX_LATENCY</stringProp>',
+        f'            <stringProp name="Argument.value">${{__P(max_latency, {max(3000, sla_p95 * 2)})}}</stringProp>',
+        '            <stringProp name="Argument.metadata">=</stringProp>',
+        '          </elementProp>',
+        '          <elementProp name="LAST_CREATED_ID" elementType="Argument">',
+        '            <stringProp name="Argument.name">LAST_CREATED_ID</stringProp>',
+        '            <stringProp name="Argument.value">1</stringProp>',
+        '            <stringProp name="Argument.metadata">=</stringProp>',
+        '          </elementProp>',
         '          <elementProp name="BEARER_TOKEN" elementType="Argument">',
         '            <stringProp name="Argument.name">BEARER_TOKEN</stringProp>',
         '            <stringProp name="Argument.value"></stringProp>',
@@ -469,9 +479,9 @@ def build_jmx_xml(
             f'{indent}    <intProp name="Assertion.test_type">40</intProp>',
             f'{indent}  </ResponseAssertion>',
             f'{indent}  <hashTree/>',
-            f'{indent}  <!-- SLA Latency Assertion -->',
-            f'{indent}  <DurationAssertion guiclass="DurationAssertionGui" testclass="DurationAssertion" testname="Assert SLA Latency (&lt; ${{SLA_P95}}ms)" enabled="true">',
-            f'{indent}    <stringProp name="DurationAssertion.duration">${{SLA_P95}}</stringProp>',
+            f'{indent}  <!-- SLA Ceiling Assertion (Percentile P95 is validated post-run by jtl_analyzer.py) -->',
+            f'{indent}  <DurationAssertion guiclass="DurationAssertionGui" testclass="DurationAssertion" testname="Assert Max Latency Ceiling (&lt; ${{MAX_LATENCY}}ms)" enabled="true">',
+            f'{indent}    <stringProp name="DurationAssertion.duration">${{MAX_LATENCY}}</stringProp>',
             f'{indent}  </DurationAssertion>',
             f'{indent}  <hashTree/>'
         ])
@@ -492,7 +502,7 @@ def build_jmx_xml(
                 f'{indent}  <!-- Deep Correlation: Random Array Item Selection (Match No: 0) -->',
                 f'{indent}  <JSONPostProcessor guiclass="JSONPostProcessorGui" testclass="JSONPostProcessor" testname="JSON Extractor - Random Item Selector" enabled="true">',
                 f'{indent}    <stringProp name="JSONPostProcessor.referenceNames">RANDOM_ITEM_ID</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..items[?(@.stock &gt; 0)].id, $..id, $..code</stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..id</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.match_numbers">0</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.defaultValues">${{RANDOM_ITEM_ID}}</stringProp>',
                 f'{indent}  </JSONPostProcessor>',
@@ -505,7 +515,7 @@ def build_jmx_xml(
                 f'{indent}  <!-- Auto-Extract Dynamic Bearer Token -->',
                 f'{indent}  <JSONPostProcessor guiclass="JSONPostProcessorGui" testclass="JSONPostProcessor" testname="JSON Extractor - Bearer Token" enabled="true">',
                 f'{indent}    <stringProp name="JSONPostProcessor.referenceNames">BEARER_TOKEN</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$.token, $.access_token, $.data.token, $.data.access_token</stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..[\'token\',\'access_token\']</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.match_numbers">1</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.defaultValues">${{BEARER_TOKEN}}</stringProp>',
                 f'{indent}  </JSONPostProcessor>',
@@ -516,9 +526,9 @@ def build_jmx_xml(
                 f'{indent}  <!-- Auto-Extract Created Entity ID -->',
                 f'{indent}  <JSONPostProcessor guiclass="JSONPostProcessorGui" testclass="JSONPostProcessor" testname="JSON Extractor - Entity ID" enabled="true">',
                 f'{indent}    <stringProp name="JSONPostProcessor.referenceNames">LAST_CREATED_ID</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$.id, $.code, $.data.id, $.data.code</stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.jsonPathExprs">$..[\'id\',\'code\']</stringProp>',
                 f'{indent}    <stringProp name="JSONPostProcessor.match_numbers">1</stringProp>',
-                f'{indent}    <stringProp name="JSONPostProcessor.defaultValues"></stringProp>',
+                f'{indent}    <stringProp name="JSONPostProcessor.defaultValues">${{LAST_CREATED_ID}}</stringProp>',
                 f'{indent}  </JSONPostProcessor>',
                 f'{indent}  <hashTree/>'
             ])
@@ -752,7 +762,10 @@ def parse_openapi_for_jmeter(spec_data: Dict[str, Any]) -> tuple:
 
             def replace_path_param(match):
                 pname = match.group(1)
-                if pname.lower() in ("id", "categoryid", "entityid", "userid"):
+                plow = pname.lower()
+                if plow in ("itemid", "productid", "item_id", "product_id"):
+                    return "${RANDOM_ITEM_ID}"
+                if plow in ("id", "categoryid", "entityid", "userid", "orderid", "order_id"):
                     return "${LAST_CREATED_ID}"
                 return f"${{{pname}}}"
 
@@ -794,6 +807,25 @@ def parse_openapi_for_jmeter(spec_data: Dict[str, Any]) -> tuple:
                 "expected_status": expected_status
             })
 
+    def sampler_sort_key(s: Dict[str, Any]) -> int:
+        p = s.get("path", "").lower()
+        m = s.get("method", "GET")
+        if "auth" in p or "login" in p or "token" in p:
+            return 1
+        if m == "POST" and "{" not in s.get("path", "") and "${" not in s.get("path", ""):
+            return 2
+        if m == "GET" and "{" not in s.get("path", "") and "${" not in s.get("path", ""):
+            return 3
+        if m == "GET":
+            return 4
+        if m in ("PUT", "PATCH"):
+            return 5
+        if m == "DELETE":
+            return 6
+        return 7
+
+    samplers.sort(key=sampler_sort_key)
+
     return plan_name, base_host, protocol, port, samplers
 
 
@@ -993,8 +1025,8 @@ def main():
         plan_name, base_host, protocol, port, samplers = parse_openapi_for_jmeter(spec_data)
     else:
         # Fallback to built-in sample spec
-        from export_postman_collection import get_sample_spec
-        spec_data = get_sample_spec()
+        from export_postman_collection import get_domain_spec
+        spec_data = get_domain_spec("ecommerce")
         plan_name, base_host, protocol, port, samplers = parse_openapi_for_jmeter(spec_data)
 
     # Base URL override if provided

package/tools/infer_linter.py

@@ -154,21 +154,40 @@ def analyze_script(file_path):
 
 
 def run_infer_linter(target_dir=None):
-    """Scans all Groovy test scripts in target_dir or Scripts/."""
-    scan_dir = target_dir or SCRIPTS_DIR
-    if not os.path.exists(scan_dir):
-        script_files = []
-    elif os.path.isfile(scan_dir):
-        script_files = [scan_dir]
+    """Scans test scripts across Groovy, TypeScript, JavaScript, Python, and Java."""
+    EXTENSIONS = ("*.groovy", "*.ts", "*.js", "*.py", "*.java")
+
+    if target_dir:
+        if os.path.isfile(target_dir):
+            script_files = [target_dir]
+            scan_dir = os.path.dirname(target_dir)
+        elif os.path.isdir(target_dir):
+            scan_dir = target_dir
+            script_files = []
+            for ext in EXTENSIONS:
+                script_files.extend(glob.glob(os.path.join(scan_dir, "**", ext), recursive=True))
+        else:
+            scan_dir = target_dir
+            script_files = []
     else:
-        script_files = glob.glob(os.path.join(scan_dir, "**", "*.groovy"), recursive=True)
+        # Search candidate directories across test frameworks (Katalon, Playwright, Pytest, Cypress)
+        script_files = []
+        scan_dir = SCRIPTS_DIR
+        for cand in ["Scripts", "tests", "test", "e2e", "specs", "cypress"]:
+            cand_path = os.path.join(REPO_ROOT, cand)
+            if os.path.isdir(cand_path):
+                for ext in EXTENSIONS:
+                    script_files.extend(glob.glob(os.path.join(cand_path, "**", ext), recursive=True))
+                if script_files:
+                    scan_dir = cand_path
+                    break
 
     results = []
     critical_count = 0
     warning_count = 0
     clean_count = 0
 
-    for s in sorted(script_files):
+    for s in sorted(set(script_files)):
         res = analyze_script(s)
         results.append(res)
         crit = sum(1 for d in res["defects"] if d["severity"] == "CRITICAL")
@@ -179,17 +198,28 @@ def run_infer_linter(target_dir=None):
             clean_count += 1
 
     total_scripts = len(script_files)
-    health_score = 100.0 if total_scripts == 0 else (((total_scripts - critical_count) / total_scripts) * 100)
-    clean_pct = (clean_count / total_scripts * 100) if total_scripts > 0 else 100.0
+    if total_scripts == 0:
+        health_score = 0.0
+        clean_pct = 0.0
+    else:
+        health_score = round(((total_scripts - critical_count) / total_scripts) * 100, 1)
+        clean_pct = round((clean_count / total_scripts) * 100, 1)
 
     print(f"\n{BOLD}{CYAN}======================================================================{RESET}")
     print(f"{BOLD}{CYAN}    ENTERPRISE STATIC DEFECT & FAKE-PASS SENTINEL (Meta Infer-Style)        {RESET}")
     print(f"{BOLD}{CYAN}======================================================================{RESET}")
-    print(f"  Target Scope            : {total_scripts} Groovy Test Scripts in {os.path.basename(scan_dir)}/")
-    print(f"  Critical Defects        : {RED if critical_count > 0 else GREEN}{critical_count}{RESET} (Swallowed exceptions, empty scripts)")
-    print(f"  Warnings / Suggestions  : {YELLOW if warning_count > 0 else GREEN}{warning_count}{RESET} (Missing explicit asserts, excessive delays)")
-    print(f"  Clean Scripts           : {GREEN}{clean_count}/{total_scripts} ({clean_pct:.1f}%){RESET}")
-    print(f"  Codebase Health Score   : {GREEN if health_score == 100 else YELLOW}{health_score:.1f}%{RESET}")
+    if total_scripts == 0:
+        print(f"  Target Scope            : 0 Test Scripts discovered in {os.path.basename(scan_dir)}/ (No tests found)")
+        print(f"  Critical Defects        : {GREEN}0{RESET}")
+        print(f"  Warnings / Suggestions  : {GREEN}0{RESET}")
+        print(f"  Clean Scripts           : 0/0 (N/A)")
+        print(f"  Codebase Health Score   : {YELLOW}N/A (0 test scripts discovered){RESET}")
+    else:
+        print(f"  Target Scope            : {total_scripts} Test Scripts in {os.path.basename(scan_dir)}/ (Polyglot)")
+        print(f"  Critical Defects        : {RED if critical_count > 0 else GREEN}{critical_count}{RESET} (Swallowed exceptions, empty scripts)")
+        print(f"  Warnings / Suggestions  : {YELLOW if warning_count > 0 else GREEN}{warning_count}{RESET} (Missing explicit asserts, excessive delays)")
+        print(f"  Clean Scripts           : {GREEN}{clean_count}/{total_scripts} ({clean_pct:.1f}%){RESET}")
+        print(f"  Codebase Health Score   : {GREEN if health_score == 100 else YELLOW}{health_score:.1f}%{RESET}")
     print(f"{BOLD}{CYAN}======================================================================{RESET}\n")
 
     # Print defect breakdown if any

package/tools/jtl_analyzer.py

@@ -362,7 +362,7 @@ def main():
     parser.add_argument("--sla-p95", type=float, default=None, help="P95 Latency threshold in ms (fails if exceeded).")
     parser.add_argument("--sla-p99", type=float, default=None, help="P99 Latency threshold in ms (fails if exceeded).")
     parser.add_argument("--sla-avg", type=float, default=None, help="Average Latency threshold in ms (fails if exceeded).")
-    parser.add_argument("--max-error-rate", type=float, default=None, help="Maximum allowed error rate percentage (e.g. 1.0 = 1%).")
+    parser.add_argument("--max-error-rate", type=float, default=None, help="Maximum allowed error rate percentage (e.g. 1.0 = 1%%).")
     parser.add_argument("--markdown", "-m", help="Output path for Markdown summary report.")
     parser.add_argument("--json", "-j", help="Output path for JSON summary metrics.")
     parser.add_argument("--telemetry", help="Path to server telemetry CSV (timestamp, cpu_pct, memory_pct, db_pool_pct) for Full-Stack APM correlation.")

package/tools/mcp_excel_server.ps1

@@ -160,7 +160,7 @@ while (($line = $inputReader.ReadLine()) -ne $null) {
                 result = @{
                     protocolVersion = "2024-11-05"
                     capabilities = @{ tools = @{} }
-                    serverInfo = @{ name = "excel-qa-mcp-server"; version = "2.2.2" }
+                    serverInfo = @{ name = "excel-qa-mcp-server"; version = "2.2.4" }
                 }
             }
             [System.Console]::Out.WriteLine(($resp | ConvertTo-Json -Compress -Depth 10))

package/tools/mcp_server.py

@@ -43,7 +43,7 @@ import traffic_session_converter
 import visual_som_helper
 
 SERVER_NAME = "enterprise-agent-qa"
-SERVER_VERSION = "2.2.2"
+SERVER_VERSION = "2.2.4"
 
 MCP_TOOLS = [
     {

package/tools/micro_mutator.py

@@ -68,7 +68,7 @@ ASSERTION_PATTERN = re.compile(
 
 # Tautological / fake assertions that do not test application logic
 TAUTOLOGY_PATTERN = re.compile(
-    r'(?:assert\s+(?:true|1\s*==\s*1)\b|assertEquals\s*\(\s*true\s*,\s*true\s*\)|expect\s*\(\s*true\s*\)\.toBe\s*\(\s*true\s*\)|assertTrue\s*\(\s*true\s*\))',
+    r'(?:assert\s+(?:true|1\s*==\s*1)\b|assert\s+([a-zA-Z_]\w*)\s*==\s*\1\b|assertEquals\s*\(\s*([a-zA-Z_]\w*)\s*,\s*\2\s*\)|expect\s*\(\s*([a-zA-Z_]\w*)\s*\)\.toBe\s*\(\s*\3\s*\)|assertTrue\s*\(\s*true\s*\))',
     re.IGNORECASE
 )
 
@@ -195,7 +195,12 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
     - If mutant is inside an unasserted block or swallowed exception: mutant SURVIVES.
     """
     if not mutants:
-        return mutants, 100.0
+        has_asserts = any(
+            ASSERTION_PATTERN.search(l) and not TAUTOLOGY_PATTERN.search(l)
+            for l in code.splitlines()
+            if not l.strip().startswith(("//", "#", "/*"))
+        )
+        return mutants, (100.0 if has_asserts else 0.0)
 
     lines = code.splitlines()
     has_empty_catch = bool(EMPTY_CATCH_PATTERN.search(code))
@@ -245,6 +250,55 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
     return mutants, score
 
 
+def evaluate_mutants_dynamically(file_path: str, code: str, mutants: List[Dict[str, Any]], test_cmd: str) -> Tuple[List[Dict[str, Any]], float]:
+    """
+    Executes live mutation testing by injecting mutants into disk file and executing test_cmd.
+    If the test command fails (exit code != 0), the mutant is KILLED by the test suite.
+    If the test command passes (exit code == 0), the mutant SURVIVED (unasserted logic branch).
+    Safely restores original file content in all cases.
+    """
+    if not mutants:
+        return mutants, 0.0
+
+    killed_count = 0
+    abs_path = os.path.abspath(file_path)
+
+    try:
+        for m in mutants:
+            mutated_code = m["mutated_code"]
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(mutated_code)
+
+            try:
+                proc = subprocess.run(
+                    test_cmd,
+                    shell=True,
+                    capture_output=True,
+                    timeout=30,
+                    text=True
+                )
+                if proc.returncode != 0:
+                    m["status"] = "KILLED"
+                    m["reason"] = f"Dynamic test caught mutant: command failed (exit code {proc.returncode})"
+                    killed_count += 1
+                else:
+                    m["status"] = "SURVIVED"
+                    m["reason"] = "Dynamic test suite passed unconditionally: missing assertion for this mutant."
+            except subprocess.TimeoutExpired:
+                m["status"] = "KILLED"
+                m["reason"] = "Mutant triggered execution timeout (> 30s): caught by runtime guard"
+                killed_count += 1
+            except Exception as e:
+                m["status"] = "SURVIVED"
+                m["reason"] = f"Test execution error: {e}"
+    finally:
+        with open(abs_path, "w", encoding="utf-8") as f:
+            f.write(code)
+
+    score = evaluate_mutation_score(killed_count, len(mutants))
+    return mutants, score
+
+
 def scan_directory_for_mutants(target_dir: str) -> List[Dict[str, Any]]:
     """Scans target test/page scripts and generates a collection of mutants."""
     all_mutants = []
@@ -269,21 +323,23 @@ def scan_directory_for_mutants(target_dir: str) -> List[Dict[str, Any]]:
 def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "") -> Dict[str, Any]:
     """
     Evaluates target file or directory for mutation robustness.
-    Returns complete mutation report dictionary.
+    Dispatches to live test execution if test_cmd is provided, or static heuristic otherwise.
     """
     target = os.path.abspath(target_path)
     all_mutants = []
+    exec_mode = "DYNAMIC" if test_cmd else "STATIC"
 
     if os.path.isfile(target):
         with open(target, "r", encoding="utf-8", errors="ignore") as f:
             code = f.read()
         mutants = generate_mutants_for_code(code, file_path=os.path.basename(target))
-        evaluated_mutants, score = evaluate_mutants_statically(code, mutants)
+        if test_cmd:
+            evaluated_mutants, score = evaluate_mutants_dynamically(target, code, mutants, test_cmd)
+        else:
+            evaluated_mutants, score = evaluate_mutants_statically(code, mutants)
         all_mutants.extend(evaluated_mutants)
     else:
-        # Directory evaluation
         valid_exts = {".groovy", ".py", ".ts", ".js"}
-        total_killed = 0
         for root, _, files in os.walk(target):
             for f in files:
                 if any(f.endswith(ext) for ext in valid_exts):
@@ -293,7 +349,10 @@ def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "
                             code = fp.read()
                         rel_path = os.path.relpath(file_full, target)
                         f_mutants = generate_mutants_for_code(code, file_path=rel_path)
-                        eval_m, _ = evaluate_mutants_statically(code, f_mutants)
+                        if test_cmd:
+                            eval_m, _ = evaluate_mutants_dynamically(file_full, code, f_mutants, test_cmd)
+                        else:
+                            eval_m, _ = evaluate_mutants_statically(code, f_mutants)
                         all_mutants.extend(eval_m)
                     except Exception:
                         pass
@@ -305,6 +364,18 @@ def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "
     survived = sum(1 for m in all_mutants if m["status"] == "SURVIVED")
     passed = score >= min_score
 
+    return {
+        "target": target,
+        "mode": exec_mode,
+        "total_mutants": len(all_mutants),
+        "killed": killed,
+        "survived": survived,
+        "mutation_score": score,
+        "min_score": min_score,
+        "passed": passed,
+        "mutants": all_mutants
+    }
+
     return {
         "target": target,
         "total_mutants": len(all_mutants),