igel-qe-core 1.0.7 → 1.0.9

package/dist/cli/index.js

@@ -15,9 +15,26 @@ program
     .description("IGEL QE Developer Experience CLI")
     .version("1.0.0");
 // ── helpers ────────────────────────────────────────────────────────────────────
+function getSystemPython() {
+    for (const cmd of ["python3", "python", "py"]) {
+        try {
+            const res = spawnSync(cmd, ["--version"], { stdio: "ignore" });
+            if (res.status === 0 || res.status === null) {
+                return cmd;
+            }
+        }
+        catch {
+            // Continue
+        }
+    }
+    return "python3";
+}
 function getPythonBin() {
-    const venv = join(PROJECT_ROOT, ".venv", "bin", "python");
-    return existsSync(venv) ? venv : "python3";
+    const isWin = process.platform === "win32";
+    const venv = isWin
+        ? join(PROJECT_ROOT, ".venv", "Scripts", "python.exe")
+        : join(PROJECT_ROOT, ".venv", "bin", "python");
+    return existsSync(venv) ? venv : getSystemPython();
 }
 function resolveRequirementsPath() {
     const primary = join(PROJECT_ROOT, "requirements.txt");
@@ -196,11 +213,11 @@ function listFrameworkContextFiles(workspaceRoot) {
     return Array.from(new Set(found)).sort();
 }
 function isCopilotCliAvailable() {
-    const check = spawnSync("copilot", ["--version"], { encoding: "utf-8" });
+    const check = spawnSync("copilot", ["--version"], { encoding: "utf-8", shell: process.platform === "win32" });
     return check.status === 0;
 }
 function isCopilotAuthenticated(workspaceRoot) {
-    const probe = spawnSync("copilot", ["-C", workspaceRoot, "-p", "Reply with exactly OK.", "--allow-all-tools", "--no-color", "-s"], { encoding: "utf-8" });
+    const probe = spawnSync("copilot", ["-C", workspaceRoot, "-p", "Reply with exactly OK.", "--allow-all-tools", "--no-color", "-s"], { encoding: "utf-8", shell: process.platform === "win32" });
     return probe.status === 0;
 }
 function ensureCopilotLogin(workspaceRoot) {
@@ -210,7 +227,7 @@ function ensureCopilotLogin(workspaceRoot) {
         return true;
     console.log(chalk.yellow("   ⚠ GitHub Copilot CLI is not authenticated."));
     console.log(chalk.yellow("   → Please complete Copilot login to continue context enrichment."));
-    const login = spawnSync("copilot", ["login"], { stdio: "inherit", encoding: "utf-8" });
+    const login = spawnSync("copilot", ["login"], { stdio: "inherit", encoding: "utf-8", shell: process.platform === "win32" });
     if (login.status !== 0)
         return false;
     return isCopilotAuthenticated(workspaceRoot);
@@ -237,7 +254,7 @@ function enrichWithCopilotCli(workspaceRoot, contextFiles) {
             "--allow-all-paths",
             "--no-color",
             "-s",
-        ], { encoding: "utf-8" });
+        ], { encoding: "utf-8", shell: process.platform === "win32" });
         if (result.status === 0) {
             updated += 1;
         }
@@ -345,7 +362,7 @@ program
     if (!existsSync(venvPath)) {
         console.log(chalk.yellow("1. Creating virtual environment…"));
         try {
-            execSync(`python3 -m venv .venv`, { cwd: PROJECT_ROOT, stdio: "inherit" });
+            execSync(`${getSystemPython()} -m venv .venv`, { cwd: PROJECT_ROOT, stdio: "inherit" });
             console.log(chalk.green("   ✓ venv created"));
         }
         catch (e) {

package/dist/mcp/server.js

@@ -3,7 +3,7 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs";
@@ -11,18 +11,33 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Project root: dist/mcp/server.js -> ../../ = project root
 const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
 // Resolve the correct Python executable:
-// 1. Check for a local .venv with a Linux bin/ (created by python3 -m venv)
-// 2. Fall back to system python3 / python
+// 1. Check for a local .venv (Linux or Windows path layouts)
+// 2. Fall back to system python3 / python / py
 function resolvePythonExecutable() {
-    const candidates = [
-        path.join(PROJECT_ROOT, '.venv', 'bin', 'python'),
-        path.join(PROJECT_ROOT, '.venv', 'bin', 'python3'),
-    ];
+    const isWin = process.platform === 'win32';
+    const candidates = isWin
+        ? [
+            path.join(PROJECT_ROOT, '.venv', 'Scripts', 'python.exe'),
+            path.join(PROJECT_ROOT, '.venv', 'Scripts', 'python'),
+        ]
+        : [
+            path.join(PROJECT_ROOT, '.venv', 'bin', 'python'),
+            path.join(PROJECT_ROOT, '.venv', 'bin', 'python3'),
+        ];
     for (const c of candidates) {
         if (fs.existsSync(c))
             return c;
     }
-    // Check system python3 / python
+    // Check system python3 / python / py
+    for (const cmd of ['python3', 'python', 'py']) {
+        try {
+            const res = spawnSync(cmd, ['--version'], { stdio: 'ignore' });
+            if (res.status === 0 || res.status === null) {
+                return cmd;
+            }
+        }
+        catch { }
+    }
     return 'python3';
 }
 const server = new Server({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "igel-qe-core",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "IGEL QE Developer Experience Layer (CLI & MCP)",
   "type": "module",
   "publishConfig": {

package/src/agents/automation_design_agent.py

@@ -15,6 +15,11 @@ class AutomationPlan(BaseModel):
     page_objects: List[str] = Field(default_factory=list)
     fixtures: List[str] = Field(default_factory=list)
     utilities: List[str] = Field(default_factory=list)
+    # Reusability Metric:
+    # (No. of reusable components generated / Total components generated) × 100 → normalised 0-1
+    reusability_score: float = 0.0
+    registry_sourced_count: int = 0
+    total_components_count: int = 0
     
 _SYSTEM_PROMPT = load_prompt(
         "automation_design.md",
@@ -106,15 +111,43 @@ def design_automation_plan(test_cases: List[TestCaseWithConfidence]) -> Automati
         
         content = response.choices[0].message.content or "{}"
         data = json.loads(content)
-        
+
+        pos = data.get("page_objects", [])
+        fixtures_list = data.get("fixtures", [])
+        utils_list = data.get("utilities", [])
+
+        # ── Reusability Metric ────────────────────────────────────────────────
+        # Formula: (No. of reusable components / Total components) × 100 → 0-1
+        # A component is 'reusable' if it was drawn from the Asset Registry (available_assets).
+        all_registry_names: set[str] = set()
+        for asset_list in available_assets.values():
+            for entry in asset_list:
+                # Entry format: "name (description...)"
+                name_part = entry.split("(")[0].strip()
+                all_registry_names.add(name_part.lower())
+
+        all_generated = pos + fixtures_list + utils_list
+        registry_sourced = sum(
+            1 for c in all_generated
+            if c.split("(")[0].strip().lower() in all_registry_names
+        )
+        total_components = len(all_generated)
+        reusability = (registry_sourced / total_components) if total_components > 0 else 0.0
+
         plan = AutomationPlan(
-            page_objects=data.get("page_objects", []),
-            fixtures=data.get("fixtures", []),
-            utilities=data.get("utilities", [])
+            page_objects=pos,
+            fixtures=fixtures_list,
+            utilities=utils_list,
+            reusability_score=round(reusability, 4),
+            registry_sourced_count=registry_sourced,
+            total_components_count=total_components,
+        )
+        logger.info(
+            "Designed Automation Plan with %d POs, %d fixtures | reusability=%.2f",
+            len(plan.page_objects), len(plan.fixtures), reusability,
         )
-        logger.info(f"Designed Automation Plan with {len(plan.page_objects)} POs, {len(plan.fixtures)} fixtures")
         return plan
-        
+
     except Exception as e:
         logger.error(f"Failed to design automation plan: {e}")
         return AutomationPlan()

package/src/agents/confidence_agent.py

@@ -1,9 +1,9 @@
 import logging
 from src.models.test_requirement import (
-    GeneratedTestCase, 
+    GeneratedTestCase,
     ScenarioWithRules,
     ConfidenceMetrics,
-    TestCaseWithConfidence
+    TestCaseWithConfidence,
 )
 from src.core.context_engine import SourceReport
 from src.core.evidence_resolver import ResolvedContext
@@ -12,21 +12,116 @@ from src.agents.validation_agent import validate_structural
 
 logger = logging.getLogger(__name__)
 
+
+# ── Parameter Calculation Helpers ─────────────────────────────────────────────
+
 def evaluate_completeness(tc: GeneratedTestCase) -> float:
-    """Evaluate completeness of steps, data, and expected results."""
+    """Evaluate structural completeness of steps (action + data + expected_result).
+
+    Used by Structural Quality dimension.
+    Formula proxy: each complete step scores 1.0; partial steps score proportionally.
+    """
     if not tc.steps:
         return 0.0
-    
     score = 0.0
     for step in tc.steps:
         step_score = 0.0
-        if step.action: step_score += 0.4
-        if step.data: step_score += 0.2
-        if step.expected_result: step_score += 0.4
+        if step.action:
+            step_score += 0.4
+        if step.data:
+            step_score += 0.2
+        if step.expected_result:
+            step_score += 0.4
         score += step_score
-        
     return score / len(tc.steps)
 
+
+def compute_contextual_relevance(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
+    """Contextual Relevance — Degree to which generated test cases align with requirement/business context.
+
+    Formula: (No. of test steps mapped to requirement context / Total generated test steps) × 100 → normalised 0-1.
+    Mapping heuristic: a step is considered 'mapped' if its action is non-empty and can be linked back
+    to at least one of the scenario's business rules (via text intersection).
+    """
+    if not tc.steps:
+        return 0.0
+    rule_keywords: set[str] = set()
+    for rule in scenario.business_rules:
+        for word in rule.description.lower().split():
+            if len(word) > 4:
+                rule_keywords.add(word)
+
+    mapped = 0
+    for step in tc.steps:
+        action_words = set(step.action.lower().split())
+        if rule_keywords and action_words & rule_keywords:
+            mapped += 1
+        elif step.action:
+            # Fallback: if no keyword overlap but step exists, give partial credit
+            mapped += 0.5
+
+    return min(1.0, (mapped / len(tc.steps)))
+
+
+def compute_hallucination_control(tc: GeneratedTestCase, resolved_context: ResolvedContext) -> float:
+    """Hallucination — Percentage of generated artifacts NOT containing non-existent entities.
+
+    Formula: (No. of non-hallucinated entities / Total generated entities) × 100 → normalised 0-1.
+    Detection heuristic: presence of unresolved source conflicts in resolved_context signals that the
+    AI may have invented information. Zero conflicts = no hallucination detected.
+    """
+    conflict_count = len(resolved_context.conflicting_sources)
+    # Each conflict reduces confidence. Cap at 5 conflicts = 0 score.
+    return max(0.0, 1.0 - (conflict_count * 0.2))
+
+
+def compute_bias_fairness_control(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
+    """Bias/Fairness Control — Ensures generation covers all personas, locales, negative and edge cases.
+
+    Formula: (No. of required personas/scenarios covered / Total identified) × 100 → normalised 0-1.
+    Coverage heuristic: checks if positive, negative and edge rule types are present in the business rules,
+    and if the specific TC covers one of these.
+    """
+    rule_types_present = {rule.rule_type for rule in scenario.business_rules}
+    total_expected = {"positive", "negative", "edge"}
+    covered = rule_types_present & total_expected
+    coverage_ratio = len(covered) / len(total_expected)
+
+    # Bonus: TC itself covers its declared type
+    if tc.test_type in covered:
+        coverage_ratio = min(1.0, coverage_ratio + 0.15)
+
+    return round(coverage_ratio, 4)
+
+
+def compute_business_rule_coverage(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
+    """Business Rule Coverage — Checks how well generated steps address the identified business rules.
+
+    Formula: (No. of business rules covered by test steps / Total business rules) × 100 → normalised 0-1.
+    """
+    if not scenario.business_rules:
+        return 1.0
+    return min(1.0, len(tc.steps) / len(scenario.business_rules))
+
+
+def compute_requirement_clarity(scenario: ScenarioWithRules, source_report: SourceReport) -> float:
+    """Requirement Clarity — How well the upstream requirement was understood.
+
+    Formula: Determined by presence of structured business rules AND multi-source corroboration.
+    """
+    has_rules = 1.0 if scenario.business_rules else 0.5
+    sources_found = sum([
+        source_report.jira_found,
+        source_report.confluence_found,
+        source_report.postgres_kb_found,
+        source_report.igel_os12_docs_found,
+    ])
+    source_bonus = min(0.5, sources_found / 4 * 0.5)
+    return min(1.0, has_rules * 0.5 + source_bonus)
+
+
+# ── Main Confidence Computation ───────────────────────────────────────────────
+
 def compute_two_level_confidence(
     tc: GeneratedTestCase,
     scenario: ScenarioWithRules,
@@ -34,81 +129,92 @@ def compute_two_level_confidence(
     source_report: SourceReport,
     policy: PolicyConfig,
 ) -> TestCaseWithConfidence:
-    """
-    Computes two levels of confidence using purely deterministic structural checks.
+    """Compute the full confidence score using the 8-parameter framework.
+
+    Pre-execution parameters (set here):
+      1. Contextual Relevance       – steps mapped to req context
+      2. Hallucination Control      – grounded vs invented entities
+      3. Bias/Fairness Control      – persona/scenario type coverage
+      4. Business Rule Coverage     – rules addressed by steps
+      5. Requirement Clarity        – clarity of upstream requirement
+      6. Structural Quality         – step completeness (action+data+expected)
+
+    Post-execution parameters (set by ExecutionValidationAgent / HealingAgent):
+      7. Maintainability            – complexity + duplication (in ExecutionMetrics)
+      8. First-Pass Success         – runtime result on first run (in ExecutionMetrics)
+      9. Reusability                – registry-sourced vs new components (in ExecutionMetrics)
+     10. Flakiness                  – historical inconsistency rate (in ExecutionMetrics)
     """
     dims = policy.confidence_dimensions
 
-    # 1. Context Strength (Informational)
+    # ── Pre-Execution Dimensions ──────────────────────────────────────────────
+
+    # 1. Context Strength (informational, not weighted)
     sources_found = sum([
-        source_report.jira_found, source_report.confluence_found,
-        source_report.postgres_kb_found, source_report.igel_os12_docs_found,
+        source_report.jira_found,
+        source_report.confluence_found,
+        source_report.postgres_kb_found,
+        source_report.igel_os12_docs_found,
     ])
     context_strength = min(1.0, sources_found / 4.0)
 
-    # 2. Generation Confidence: Requirement Clarity (25%)
-    # Deterministic check: Are ACs, Business Rules, Dependencies, Environment present in the structured scenario?
-    # Since our schema for ScenarioWithRules just has scenario and business_rules, 
-    # we check for presence of multiple business_rules as a proxy for clarity.
-    requirement_clarity = 1.0 if scenario.business_rules else 0.5
+    # 2. Contextual Relevance
+    contextual_relevance = compute_contextual_relevance(tc, scenario)
 
-    # 3. Generation Confidence: Evidence Quality (20%)
-    # Deterministic: Based on resolved conflicts
-    conflict_count = len(resolved_context.conflicting_sources)
-    evidence_quality = 1.0 if conflict_count == 0 else max(0.0, 1.0 - (0.3 * conflict_count))
+    # 3. Hallucination Control (replaces evidence_quality)
+    hallucination_control = compute_hallucination_control(tc, resolved_context)
 
-    # 4. Generation Confidence: Business Rule Coverage (15%)
-    # Deterministic: Number of extracted rule objects vs mapped steps
-    rule_coverage = 1.0 if len(tc.steps) >= len(scenario.business_rules) else 0.5
+    # 4. Bias/Fairness Control (replaces scenario_coverage)
+    bias_fairness_control = compute_bias_fairness_control(tc, scenario)
 
-    # 5. Generation Confidence: Traceability Coverage (15%)
-    # Deterministic: Do steps have mapped requirement IDs? (Proxy using tc_reference mapped)
-    traceability = 1.0 if "S" in tc.tc_reference and tc.business_rule else 0.0
+    # 5. Business Rule Coverage
+    business_rule_coverage = compute_business_rule_coverage(tc, scenario)
 
-    # 6. Generation Confidence: Scenario Coverage (15%)
-    # Deterministic: Does the generated suite contain Positive + Negative + Edge tags?
-    # Checking the single TC test_type
-    scenario_score = 1.0 if tc.test_type in ["positive", "negative", "edge"] else 0.5
+    # 6. Requirement Clarity
+    requirement_clarity = compute_requirement_clarity(scenario, source_report)
 
-    # 7. Generation Confidence: Structural Quality (10%)
-    # Deterministic: Preconditions, steps, expected results (existing validation_agent.py)
-    struct_ok, struct_errs = validate_structural(tc, scenario)
+    # 7. Structural Quality
+    struct_ok, _ = validate_structural(tc, scenario)
     structural_quality = evaluate_completeness(tc) if struct_ok else 0.0
 
-    # Weighted total (Final Confidence)
+    # ── Weighted Final Score ──────────────────────────────────────────────────
+    # Weights pulled from policy dimensions; field names updated to match new params
     total = (
-        requirement_clarity * dims.requirement_clarity +
-        evidence_quality * dims.evidence_quality +
-        rule_coverage * dims.business_rule_coverage +
-        traceability * dims.traceability_coverage +
-        scenario_score * dims.scenario_coverage +
-        structural_quality * dims.structural_quality
+        contextual_relevance   * getattr(dims, "contextual_relevance",   0.25) +
+        hallucination_control  * getattr(dims, "hallucination_control",  0.20) +
+        bias_fairness_control  * getattr(dims, "bias_fairness_control",  0.15) +
+        business_rule_coverage * getattr(dims, "business_rule_coverage", 0.15) +
+        requirement_clarity    * getattr(dims, "requirement_clarity",    0.15) +
+        structural_quality     * getattr(dims, "structural_quality",     0.10)
     )
 
     metrics = ConfidenceMetrics(
         context_strength=context_strength,
         requirement_clarity=requirement_clarity,
-        evidence_quality=evidence_quality,
-        business_rule_coverage=rule_coverage,
-        traceability_coverage=traceability,
-        scenario_coverage=scenario_score,
+        hallucination_control=hallucination_control,
+        business_rule_coverage=business_rule_coverage,
+        contextual_relevance=contextual_relevance,
+        bias_fairness_control=bias_fairness_control,
         structural_quality=structural_quality,
-        final_confidence=total,
+        final_confidence=round(total, 4),
     )
 
     tc.confidence_score = total
-    tc.confidence_metrics = metrics.model_dump() if hasattr(metrics, 'model_dump') else metrics.dict()
+    tc.confidence_metrics = metrics.model_dump() if hasattr(metrics, "model_dump") else metrics.dict()
 
     bands = policy.confidence_bands
     is_approved = total >= bands.auto_approved
 
     if not is_approved:
-        logger.info(f"Test case {tc.tc_reference} needs review (score: {total:.2f})")
+        logger.info(
+            "Test case %s needs review (score: %.2f | contextual_relevance=%.2f, hallucination=%.2f, bias=%.2f)",
+            tc.tc_reference, total, contextual_relevance, hallucination_control, bias_fairness_control,
+        )
     else:
-        logger.info(f"Test case {tc.tc_reference} auto-approved (score: {total:.2f})")
+        logger.info("Test case %s auto-approved (score: %.2f)", tc.tc_reference, total)
 
     return TestCaseWithConfidence(
         test_case=tc,
         confidence=metrics,
-        is_approved=is_approved
+        is_approved=is_approved,
     )

package/src/agents/execution_validation_agent.py

@@ -2,18 +2,98 @@ import ast
 import logging
 import subprocess
 from pathlib import Path
-from typing import Tuple, List, Set
+from typing import Tuple, Set
 
 from src.db.client import get_conn
+from src.models.test_requirement import ExecutionMetrics
 
 logger = logging.getLogger(__name__)
 
+
+# ── Static Complexity Analyser (lightweight, no external deps) ─────────────────
+
+def _compute_cyclomatic_complexity(tree: ast.Module) -> int:
+    """Count decision points to approximate cyclomatic complexity.
+
+    Counts: if/elif/for/while/try/except/with/assert branches.
+    Complexity = 1 + decision_points (baseline 1 per function).
+    """
+    decision_nodes = (
+        ast.If, ast.For, ast.While, ast.Try,
+        ast.ExceptHandler, ast.With, ast.Assert,
+    )
+    return sum(1 for _ in ast.walk(tree) if isinstance(_, decision_nodes))
+
+
+def _compute_duplication_score(code: str) -> float:
+    """Approximate duplication score by detecting repeated non-trivial line blocks.
+
+    Returns a 0-100 score where 0 = no duplication, 100 = fully duplicated.
+    """
+    lines = [l.strip() for l in code.splitlines() if l.strip() and not l.strip().startswith("#")]
+    if not lines:
+        return 0.0
+    seen: dict[str, int] = {}
+    for line in lines:
+        seen[line] = seen.get(line, 0) + 1
+    duplicated = sum(count - 1 for count in seen.values() if count > 1)
+    return round(min(100.0, (duplicated / len(lines)) * 100), 2)
+
+
+def _count_style_violations(code: str) -> int:
+    """Count basic style violations (magic numbers, overly long lines, missing docstrings).
+
+    Each violation adds to the Maintainability penalty.
+    """
+    violations = 0
+    for line in code.splitlines():
+        if len(line) > 120:
+            violations += 1
+        # Detect magic numbers not assigned to a variable
+        import re
+        if re.search(r"\b(?<![\w=])\d{2,}\b", line) and "=" not in line:
+            violations += 1
+    return violations
+
+
+def compute_maintainability(code: str) -> Tuple[float, float, float, int]:
+    """Maintainability — Ease of modifying and understanding generated scripts.
+
+    Formula: 100 – ((Complexity Score + Duplication Score + Violations) / Max Score × 100)
+    Returns: (maintainability_score 0-1, complexity_raw, duplication_raw, violations_count)
+    """
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return 0.0, 0.0, 0.0, 0
+
+    complexity = _compute_cyclomatic_complexity(tree)
+    duplication = _compute_duplication_score(code)
+    violations = _count_style_violations(code)
+
+    # Normalise each sub-score to 0-100 range (caps prevent extreme values)
+    MAX_COMPLEXITY = 50.0   # treat 50+ branches as worst case
+    MAX_VIOLATIONS = 30.0   # treat 30+ violations as worst case
+
+    complexity_norm = min(100.0, (complexity / MAX_COMPLEXITY) * 100)
+    violation_norm = min(100.0, (violations / MAX_VIOLATIONS) * 100)
+
+    # Formula (all three sub-scores weighted equally within their sum)
+    penalty = (complexity_norm + duplication + violation_norm) / 3.0
+    maintainability_pct = max(0.0, 100.0 - penalty)
+    maintainability_score = round(maintainability_pct / 100.0, 4)
+
+    return maintainability_score, round(complexity_norm, 2), round(duplication, 2), violations
+
+
 class ExecutionValidationAgent:
     """Multi-stage validation pipeline for generated automation scripts."""
-    
+
     def __init__(self, repo_path: Path):
         self.repo_path = repo_path
-        
+
+    # ── Validation Stages ─────────────────────────────────────────────────────
+
     def validate_syntax(self, code: str) -> Tuple[bool, str]:
         """Stage 1: Check Python syntax."""
         try:
@@ -21,109 +101,147 @@ class ExecutionValidationAgent:
             return True, ""
         except SyntaxError as e:
             return False, f"SyntaxError at line {e.lineno}: {e.msg}"
-            
+
     def _get_known_assets(self, asset_type: str) -> Set[str]:
         """Fetch all known assets of a specific type from the Asset Registry."""
-        assets = set()
+        assets: Set[str] = set()
         try:
             with get_conn() as conn:
                 with conn.cursor() as cur:
-                    cur.execute("SELECT name FROM igel_asset_registry WHERE asset_type = %s", (asset_type,))
+                    cur.execute(
+                        "SELECT name FROM igel_asset_registry WHERE asset_type = %s",
+                        (asset_type,),
+                    )
                     for row in cur.fetchall():
                         assets.add(row[0])
         except Exception as e:
-            logger.error(f"Failed to query registry for {asset_type}: {e}")
+            logger.error("Failed to query registry for %s: %s", asset_type, e)
         return assets
 
     def validate_imports(self, code: str) -> Tuple[bool, str]:
         """Stage 2: Check if imported modules exist in the registry."""
         try:
-            tree = ast.parse(code)
+            ast.parse(code)
         except SyntaxError:
             return False, "Syntax invalid, cannot check imports."
-            
-        # For simplicity, we just extract 'from module import X' and check X
-        # A more robust check would analyze the actual repo path.
-        missing_imports = []
-        known_pos = self._get_known_assets("page_object")
-        known_utils = self._get_known_assets("utility")
-        known_clients = self._get_known_assets("api_client")
-        
-        all_known = known_pos | known_utils | known_clients
-        
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ImportFrom):
-                for name in node.names:
-                    # Ignore standard library and common 3rd party (pytest, allure, typing, etc.)
-                    if node.module and not any(node.module.startswith(p) for p in ["pytest", "allure", "typing", "selenium", "playwright", "os", "json", "time"]):
-                        # This is a naive check; in a real enterprise system, you'd match the import path to `file_path`
-                        pass
+        # Registry-aware import validation is advisory; non-blocking.
         return True, ""
-        
+
     def validate_fixtures(self, code: str) -> Tuple[bool, str]:
         """Stage 3: Check if requested pytest fixtures exist."""
         try:
             tree = ast.parse(code)
         except SyntaxError:
             return False, "Syntax invalid, cannot check fixtures."
-            
+
         known_fixtures = self._get_known_assets("fixture")
-        
         missing = []
         for node in ast.walk(tree):
             if isinstance(node, ast.FunctionDef) and node.name.startswith("test_"):
-                # pytest uses argument names to request fixtures
                 for arg in node.args.args:
                     arg_name = arg.arg
-                    # Ignore common built-in fixtures
-                    if arg_name not in ["request", "monkeypatch", "capsys", "tmpdir", "self", "cls"]:
+                    if arg_name not in {"request", "monkeypatch", "capsys", "tmpdir", "self", "cls"}:
                         if known_fixtures and arg_name not in known_fixtures:
-                            missing.append(f"Fixture '{arg_name}' requested by {node.name} not found in registry.")
-                            
+                            missing.append(
+                                f"Fixture '{arg_name}' requested by {node.name} not found in registry."
+                            )
         if missing:
             return False, "\n".join(missing)
         return True, ""
-        
+
     def validate_pytest_collection(self, file_path: Path) -> Tuple[bool, str]:
         """Stage 4: Perform a pytest dry-run (collection only)."""
         if not file_path.exists():
             return False, f"File {file_path} does not exist."
-            
-        # Run pytest --collect-only
         try:
-            # Note: Requires pytest to be installed in the environment running the server
             result = subprocess.run(
                 ["pytest", "--collect-only", str(file_path)],
                 capture_output=True,
                 text=True,
-                cwd=str(self.repo_path)
+                cwd=str(self.repo_path),
             )
-            
+            if result.returncode == 5:
+                return False, "Pytest collected 0 tests."
             if result.returncode != 0:
-                # 5 means no tests collected, which is also an error for us
-                if result.returncode == 5:
-                    return False, "Pytest collected 0 tests."
                 return False, f"Pytest collection failed:\n{result.stderr or result.stdout}"
-                
             return True, ""
         except Exception as e:
             return False, f"Error running pytest collection: {e}"
-            
-    def validate_pipeline(self, code: str, file_path: Path) -> Tuple[bool, str, str]:
-        """Run all execution validation stages."""
-        logger.info(f"Starting execution validation pipeline for {file_path}")
-        
+
+    # ── Main Pipeline ─────────────────────────────────────────────────────────
+
+    def validate_pipeline(self, code: str, file_path: Path) -> Tuple[bool, str, str, ExecutionMetrics]:
+        """Run all execution validation stages and compute ExecutionMetrics.
+
+        Returns: (passed: bool, status: str, error_msg: str, ExecutionMetrics)
+
+        ExecutionMetrics computed here:
+          - Maintainability   – AST-based complexity/duplication formula
+          - First-Pass Success – whether collection + syntax pass on first attempt
+          - Reusability        – populated by automation_design_agent (passed in plan)
+          - Flakiness          – historical; placeholder (0.0) until HealingAgent populates
+        """
+        logger.info("Starting execution validation pipeline for %s", file_path)
+
+        # ── Maintainability (always computed, even if later stages fail) ──────
+        maintainability, complexity_norm, duplication, violations = compute_maintainability(code)
+
         ok, err = self.validate_syntax(code)
-        if not ok: return False, "syntax_failed", err
-        
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "syntax_failed", err, exec_metrics
+
         ok, err = self.validate_imports(code)
-        if not ok: return False, "import_failed", err
-        
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "import_failed", err, exec_metrics
+
         ok, err = self.validate_fixtures(code)
-        if not ok: return False, "fixture_failed", err
-        
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "fixture_failed", err, exec_metrics
+
         ok, err = self.validate_pytest_collection(file_path)
-        if not ok: return False, "collection_failed", err
-        
-        logger.info(f"Execution validation passed for {file_path}")
-        return True, "passed", ""
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "collection_failed", err, exec_metrics
+
+        # All stages passed → First-Pass Success = True
+        exec_metrics = ExecutionMetrics(
+            maintainability_score=maintainability,
+            complexity_score=complexity_norm,
+            duplication_score=duplication,
+            violations_count=violations,
+            first_pass_success=True,
+            # reusability_score injected by caller from AutomationPlan.reusability_score
+            # flakiness_score injected by HealingAgent over time
+        )
+        logger.info(
+            "Execution validation passed for %s | maintainability=%.2f, first_pass=True",
+            file_path, maintainability,
+        )
+        return True, "passed", "", exec_metrics

package/src/agents/workflow_engine.py

@@ -2,7 +2,7 @@ import logging
 from pathlib import Path
 from typing import List, Tuple
 
-from src.models.test_requirement import TestRequirement, GeneratedTestCase, TestCaseWithConfidence
+from src.models.test_requirement import TestRequirement, GeneratedTestCase, TestCaseWithConfidence, ExecutionMetrics
 from src.agents.requirement_agent import extract_understanding
 from src.agents.scenario_agent import generate_all_scenarios
 from src.agents.testcase_agent import generate_cases_for_scenario
@@ -43,7 +43,6 @@ class WorkflowEngine:
         resolved_context = EvidenceResolver().resolve(unified_context)
         source_report = unified_context.source_report
 
-        # In reality, you'd persist `scenarios_with_rules` to DB here
         return req, scenarios_with_rules, resolved_context, source_report
         
     def run_testcase_flow(
@@ -66,11 +65,10 @@ class WorkflowEngine:
                 # 2. Structural/Traceability Validation
                 ok, errs = run_validation_pipeline(tc, sr)
                     
-                # 3. Deterministic Confidence Scoring
+                # 3. Deterministic Confidence Scoring (8-parameter framework)
                 tc_conf = compute_two_level_confidence(tc, sr, resolved_context, source_report, policy)
                 all_cases.append(tc_conf)
                 
-        # Persist to igel_generated_testcases handled by PersistenceEngine now
         return all_cases
         
     def run_script_flow(
@@ -79,14 +77,19 @@ class WorkflowEngine:
         test_cases: List[TestCaseWithConfidence],
         output_path: Path,
         plan: AutomationPlan = None,
-    ) -> Tuple[bool, str, AutomationPlan]:
-        """Approved Test Cases -> (Automation Design) -> Script -> Execution Validation"""
+    ) -> Tuple[bool, str, AutomationPlan, ExecutionMetrics]:
+        """Approved Test Cases -> (Automation Design) -> Script -> Execution Validation.
+
+        Returns: (success, message, plan_used, ExecutionMetrics)
+        ExecutionMetrics includes Maintainability, First-Pass Success, and Reusability
+        sourced from the AutomationPlan.
+        """
         logger.info(f"Starting script flow for {req.jira_key}")
 
         # Filter for approved
         approved = [tc for tc in test_cases if tc.is_approved]
         if not approved:
-            return False, "No approved test cases available for automation.", None
+            return False, "No approved test cases available for automation.", None, ExecutionMetrics()
 
         # 1. Automation Design Agent (reuse a supplied plan if present)
         if plan is None:
@@ -95,15 +98,17 @@ class WorkflowEngine:
         # 2. Script Generator
         ok, code, err = generate_script(test_cases, plan, output_path)
         if not ok:
-            return False, err, plan
+            return False, err, plan, ExecutionMetrics()
 
-        # 3. Execution Validation Pipeline
-        ok, status, err = self.exec_validator.validate_pipeline(code, output_path)
+        # 3. Execution Validation Pipeline — now returns ExecutionMetrics
+        ok, status, err, exec_metrics = self.exec_validator.validate_pipeline(code, output_path)
 
-        # Persist to igel_automation_scripts here
+        # 4. Wire Reusability from AutomationPlan into ExecutionMetrics
+        exec_metrics.reusability_score = getattr(plan, "reusability_score", 0.0)
 
         if not ok:
             logger.warning(f"Execution validation failed ({status}): {err}")
-            return False, err, plan
+            return False, err, plan, exec_metrics
+
+        return True, "Script successfully generated and validated.", plan, exec_metrics
 
-        return True, "Script successfully generated and validated.", plan

package/src/cli/index.ts

@@ -21,9 +21,26 @@ program
 
 // ── helpers ────────────────────────────────────────────────────────────────────
 
+function getSystemPython(): string {
+  for (const cmd of ["python3", "python", "py"]) {
+    try {
+      const res = spawnSync(cmd, ["--version"], { stdio: "ignore" });
+      if (res.status === 0 || res.status === null) {
+        return cmd;
+      }
+    } catch {
+      // Continue
+    }
+  }
+  return "python3";
+}
+
 function getPythonBin(): string {
-  const venv = join(PROJECT_ROOT, ".venv", "bin", "python");
-  return existsSync(venv) ? venv : "python3";
+  const isWin = process.platform === "win32";
+  const venv = isWin
+    ? join(PROJECT_ROOT, ".venv", "Scripts", "python.exe")
+    : join(PROJECT_ROOT, ".venv", "bin", "python");
+  return existsSync(venv) ? venv : getSystemPython();
 }
 
 function resolveRequirementsPath(): string | null {
@@ -206,7 +223,7 @@ function listFrameworkContextFiles(workspaceRoot: string): string[] {
 }
 
 function isCopilotCliAvailable(): boolean {
-  const check = spawnSync("copilot", ["--version"], { encoding: "utf-8" });
+  const check = spawnSync("copilot", ["--version"], { encoding: "utf-8", shell: process.platform === "win32" });
   return check.status === 0;
 }
 
@@ -214,7 +231,7 @@ function isCopilotAuthenticated(workspaceRoot: string): boolean {
   const probe = spawnSync(
     "copilot",
     ["-C", workspaceRoot, "-p", "Reply with exactly OK.", "--allow-all-tools", "--no-color", "-s"],
-    { encoding: "utf-8" },
+    { encoding: "utf-8", shell: process.platform === "win32" },
   );
   return probe.status === 0;
 }
@@ -226,7 +243,7 @@ function ensureCopilotLogin(workspaceRoot: string): boolean {
   console.log(chalk.yellow("   ⚠ GitHub Copilot CLI is not authenticated."));
   console.log(chalk.yellow("   → Please complete Copilot login to continue context enrichment."));
 
-  const login = spawnSync("copilot", ["login"], { stdio: "inherit", encoding: "utf-8" });
+  const login = spawnSync("copilot", ["login"], { stdio: "inherit", encoding: "utf-8", shell: process.platform === "win32" });
   if (login.status !== 0) return false;
   return isCopilotAuthenticated(workspaceRoot);
 }
@@ -258,7 +275,7 @@ function enrichWithCopilotCli(workspaceRoot: string, contextFiles: string[]): {
         "--no-color",
         "-s",
       ],
-      { encoding: "utf-8" },
+      { encoding: "utf-8", shell: process.platform === "win32" },
     );
 
     if (result.status === 0) {
@@ -376,7 +393,7 @@ program
     if (!existsSync(venvPath)) {
       console.log(chalk.yellow("1. Creating virtual environment…"));
       try {
-        execSync(`python3 -m venv .venv`, { cwd: PROJECT_ROOT, stdio: "inherit" });
+        execSync(`${getSystemPython()} -m venv .venv`, { cwd: PROJECT_ROOT, stdio: "inherit" });
         console.log(chalk.green("   ✓ venv created"));
       } catch (e: unknown) {
         console.log(chalk.yellow(`   ⚠ venv setup skipped: ${e instanceof Error ? e.message : String(e)}`));

package/src/cli/workflow_cli.py

@@ -496,7 +496,7 @@ def main():
                 logging.warning("Failed to read automation plan artifact; will design fresh: %s", e)
 
             output_script = output_dir / f"test_{jira_key.replace('-', '_').lower()}.py"
-            ok, msg, used_plan = engine.run_script_flow(req, approved, output_script, plan=automation_plan)
+            ok, msg, used_plan, exec_metrics = engine.run_script_flow(req, approved, output_script, plan=automation_plan)
 
             if ok and not automation_plan_used and used_plan is not None:
                 try:
@@ -521,6 +521,16 @@ def main():
                         "stage": "automation_plan",
                         "approval_checked": bool(cfg.V2_ORCHESTRATOR_ENABLED or cfg.V2_GOVERNANCE_ENFORCED or cfg.V2_APPROVAL_MANAGER_ENABLED),
                     },
+                    # ── Execution & Quality Metrics ───────────────────────────
+                    "execution_metrics": {
+                        "maintainability_score":   round(exec_metrics.maintainability_score * 100, 2),
+                        "complexity_score":         exec_metrics.complexity_score,
+                        "duplication_score":        exec_metrics.duplication_score,
+                        "violations_count":         exec_metrics.violations_count,
+                        "first_pass_success":       exec_metrics.first_pass_success,
+                        "reusability_score":        round(exec_metrics.reusability_score * 100, 2),
+                        "flakiness_score":          round(exec_metrics.flakiness_score * 100, 2),
+                    },
                     "context_projection": _best_effort_project_context(repo_path),
                 })
             else:

package/src/deploy/requirements.txt

@@ -28,6 +28,7 @@ pydantic>=2.7.0
 eval_type_backport>=0.2.0; python_version < "3.10"
 tenacity==9.0.0
 rich==13.9.4
+PyYAML>=6.0.1
 
 # OSS local reranker (CrossEncoder — free, runs on CPU/GPU)
 # Default model: BAAI/bge-reranker-v2-m3 (multilingual, best open-source for IGEL DE/EN)

package/src/mcp/server.ts

@@ -3,7 +3,7 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs";
@@ -14,17 +14,31 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
 
 // Resolve the correct Python executable:
-// 1. Check for a local .venv with a Linux bin/ (created by python3 -m venv)
-// 2. Fall back to system python3 / python
+// 1. Check for a local .venv (Linux or Windows path layouts)
+// 2. Fall back to system python3 / python / py
 function resolvePythonExecutable(): string {
-    const candidates = [
-        path.join(PROJECT_ROOT, '.venv', 'bin', 'python'),
-        path.join(PROJECT_ROOT, '.venv', 'bin', 'python3'),
-    ];
+    const isWin = process.platform === 'win32';
+    const candidates = isWin
+        ? [
+            path.join(PROJECT_ROOT, '.venv', 'Scripts', 'python.exe'),
+            path.join(PROJECT_ROOT, '.venv', 'Scripts', 'python'),
+          ]
+        : [
+            path.join(PROJECT_ROOT, '.venv', 'bin', 'python'),
+            path.join(PROJECT_ROOT, '.venv', 'bin', 'python3'),
+          ];
     for (const c of candidates) {
         if (fs.existsSync(c)) return c;
     }
-    // Check system python3 / python
+    // Check system python3 / python / py
+    for (const cmd of ['python3', 'python', 'py']) {
+        try {
+            const res = spawnSync(cmd, ['--version'], { stdio: 'ignore' });
+            if (res.status === 0 || res.status === null) {
+                return cmd;
+            }
+        } catch {}
+    }
     return 'python3';
 }
 

package/src/models/test_requirement.py

@@ -75,13 +75,23 @@ class ConfidenceMetrics(BaseModel):
     """Deterministic two-level confidence score breakdown."""
     context_strength: float = 0.0
     requirement_clarity: float = 0.0
-    evidence_quality: float = 0.0
+    hallucination_control: float = 0.0
     business_rule_coverage: float = 0.0
-    traceability_coverage: float = 0.0
-    scenario_coverage: float = 0.0
+    contextual_relevance: float = 0.0
+    bias_fairness_control: float = 0.0
     structural_quality: float = 0.0
     final_confidence: float = 0.0
     
+class ExecutionMetrics(BaseModel):
+    """Post-execution metrics for automation scripts."""
+    maintainability_score: float = 0.0
+    complexity_score: float = 0.0
+    duplication_score: float = 0.0
+    violations_count: int = 0
+    first_pass_success: bool = False
+    reusability_score: float = 0.0
+    flakiness_score: float = 0.0
+
 class TestCaseWithConfidence(BaseModel):
     """Test case bundled with its validation and confidence metrics."""
     test_case: GeneratedTestCase