data/processed/RQ2/RecruitmentAssistant-A2A/analyze_performance_breakdown_a2a.py

#!/usr/bin/env python3
"""
Performance breakdown analysis script - RecruitmentAssistant-A2A.

This script is designed for the A2A architecture (CrewAI only).

It measures 5 core components:
1. LLM_OVERHEAD - LLM reasoning time
2. Tool_OVERHEAD - tool invocation time
3. A2A_OVERHEAD - A2A communication overhead
4. Framework_OVERHEAD - CrewAI framework orchestration overhead
5. Server_OVERHEAD - server execution overhead
"""

import csv
import re
import yaml
from pathlib import Path
from typing import Dict, List, Optional, Tuple
from collections import defaultdict


class TraceNode:
    def __init__(
        self,
        node_type: str,
        name: str,
        time: Optional[float] = None,
        tokens: Optional[Dict[str, int]] = None,
        raw_line: str = "",
    ):
        self.type = node_type
        self.name = name
        self.time = time
        self.tokens = tokens or {}
        self.raw_line = raw_line
        self.children: List["TraceNode"] = []
        self.parent: Optional["TraceNode"] = None
        self.depth: int = 0
        self.in_mcp_subtree: bool = False

    def add_child(self, child: "TraceNode") -> None:
        child.parent = self
        self.children.append(child)


class ExecutionTreeParser:
    def __init__(self, md_file_path: str):
        self.file_path = Path(md_file_path)
        self.model: Optional[str] = None
        self.project: Optional[str] = None
        self.session_id: str = self.file_path.parent.name
        self.root: Optional[TraceNode] = None

    def _extract_metadata_from_path(self) -> None:
        parts = self.file_path.parts
        if "RESULTS" in parts:
            idx = parts.index("RESULTS")
            if idx + 2 < len(parts):
                self.model = parts[idx + 1]
                self.project = parts[idx + 2]

    @staticmethod
    def _parse_tokens(line: str) -> Optional[Dict[str, int]]:
        agg_pattern = r"\[∑ tokens: \((\d+)→(\d+) \[REASONING:(\d+), OUTPUT:(\d+)\], total: (\d+)\)"
        m = re.search(agg_pattern, line)
        if not m:
            llm_pattern = (
                r"\((\d+)→(\d+) \[REASONING:(\d+), OUTPUT:(\d+)\], total: (\d+)\)"
            )
            m = re.search(llm_pattern, line)
        if not m:
            return None
        return {
            "input": int(m.group(1)),
            "output": int(m.group(2)),
            "reasoning": int(m.group(3)),
            "result": int(m.group(4)),
            "total": int(m.group(5)),
        }

    @staticmethod
    def _parse_time(line: str) -> Optional[float]:
        m = re.search(r"time:\s*([\d.]+)(ms|s)", line)
        if m:
            val = float(m.group(1))
            return val / 1000.0 if m.group(2) == "ms" else val
        m = re.search(r"∑\s*time:\s*([\d.]+)(ms|s)", line)
        if m:
            val = float(m.group(1))
            return val / 1000.0 if m.group(2) == "ms" else val
        m = re.search(r"\[([\d.]+)(ms|s)\]", line)
        if m:
            val = float(m.group(1))
            return val / 1000.0 if m.group(2) == "ms" else val
        return None

    @staticmethod
    def _clean_content_line(line: str) -> str:
        clean = re.sub(r"^[│├└─\s]+", "", line).strip()
        if not clean:
            return ""
        clean = re.sub(r"^❌\s+", "", clean)
        clean = re.sub(r"\s*\(retry\s+\d+\)", "", clean)
        clean = re.sub(r"\s*\[RETRY\d+\]", "", clean)
        clean = re.sub(r"\s*\[[TRUNCATED]\]", "", clean)
        clean = re.sub(r"\s*\[ERROR:[^\]]*\]", "", clean)
        return clean.strip()

    @staticmethod
    def _parse_node_from_content(line: str, raw_line: str) -> Optional[TraceNode]:
        if not line:
            return None
        if line.startswith("[Task Created]"):
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "Task Created", "Task Created", time=time_val, raw_line=raw_line
            )
        if line.startswith("[Crew Created]"):
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "Crew Created", "Crew Created", time=time_val, raw_line=raw_line
            )
        if line.startswith("[SPAN]"):
            m = re.match(r"\[SPAN\]\s+([^\[]+)", line)
            name = m.group(1).strip() if m else "SPAN"
            tokens = ExecutionTreeParser._parse_tokens(line)
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "SPAN", name, time=time_val, tokens=tokens, raw_line=raw_line
            )
        if line.startswith("[Chain]"):
            m = re.match(r"\[Chain\]\s+([^\[]+)", line)
            name = m.group(1).strip() if m else "Chain"
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode("Chain", name, time=time_val, raw_line=raw_line)
        if line.startswith("[AGENT]"):
            m = re.match(r"\[AGENT\]\s+(.+?)(?:\s+\[|$)", line)
            name = m.group(1).strip() if m else "AGENT"
            tokens = ExecutionTreeParser._parse_tokens(line)
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "AGENT", name, time=time_val, tokens=tokens, raw_line=raw_line
            )
        if line.startswith("[Tool]"):
            m = re.match(r"\[Tool\]\s+([^\[]+?)(?:\s+\[|\s+@@@|$)", line)
            name = m.group(1).strip() if m else "Tool"
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode("Tool", name, time=time_val, raw_line=raw_line)
        if line.startswith("[LLM]"):
            m = re.match(r"\[LLM\]\s+([^\(\[]+)", line)
            name = m.group(1).strip() if m else "LLM"
            tokens = ExecutionTreeParser._parse_tokens(line)
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "LLM", name, time=time_val, tokens=tokens, raw_line=raw_line
            )
        return None

    def _mark_mcp_subtrees(self) -> None:
        if not self.root:
            return

        def dfs(node: TraceNode, in_mcp: bool) -> None:
            if node.type == "SPAN" and "mcp" in node.name:
                in_mcp = True
            node.in_mcp_subtree = in_mcp
            for ch in node.children:
                dfs(ch, in_mcp)

        dfs(self.root, False)

    def parse(self) -> Optional[TraceNode]:
        if not self.file_path.exists():
            return None
        text = self.file_path.read_text(encoding="utf-8")
        m = re.search(r"## Execution Path Tree.*?```\n(.*?)```", text, re.DOTALL)
        if not m:
            return None
        block = m.group(1)
        stack: List[TraceNode] = []
        self.root = None
        for raw in block.splitlines():
            if not raw.strip():
                continue
            pm = re.match(r"^([│├└─\s]*)", raw)
            prefix = pm.group(1) if pm else ""
            depth = len(prefix)
            clean = self._clean_content_line(raw)
            node = self._parse_node_from_content(clean, raw)
            if node is None:
                continue
            node.depth = depth
            while stack and stack[-1].depth >= depth:
                stack.pop()
            if stack:
                stack[-1].add_child(node)
            else:
                if self.root is None:
                    self.root = node
            stack.append(node)
        self._extract_metadata_from_path()
        self._mark_mcp_subtrees()
        return self.root


def iter_nodes(root: TraceNode):
    stack = [root]
    while stack:
        node = stack.pop()
        yield node
        for ch in reversed(node.children):
            stack.append(ch)


def iter_subtree(root: TraceNode):
    stack = [root]
    while stack:
        node = stack.pop()
        yield node
        for ch in reversed(node.children):
            stack.append(ch)


def find_orchestrator(root: TraceNode) -> TraceNode:
    for node in iter_nodes(root):
        if node.type == "SPAN" and "orchestrator" in node.name:
            return node
    return root


def compute_retry_time(root: TraceNode) -> float:
    """Sum time (seconds) of nodes marked as RETRY."""
    total = 0.0
    retry_pattern = re.compile(r"\(retry\s+\d+\)|\[RETRY\d+\]")
    for node in iter_nodes(root):
        if node.in_mcp_subtree:
            continue
        if node.time is None:
            continue
        if retry_pattern.search(node.raw_line):
            total += node.time
    return total


def compute_llm_overhead_for_subtree(root: TraceNode) -> float:
    """Compute LLM time (seconds) within the given subtree."""
    total = 0.0
    for node in iter_subtree(root):
        if node.in_mcp_subtree:
            continue
        if node.type == "LLM" and node.time is not None:
            total += node.time
    return total


def compute_tool_overhead_for_subtree(root: TraceNode) -> float:
    """Compute Tool time (seconds) within the given subtree."""
    total = 0.0
    for node in iter_subtree(root):
        if node.in_mcp_subtree:
            continue
        if node.type == "Tool" and node.time is not None:
            total += node.time
    return total


def compute_llm_overhead(root: TraceNode) -> float:
    """Compute global LLM time (seconds) - A2A/CrewAI does not require dedup."""
    total = 0.0
    for node in iter_nodes(root):
        if node.in_mcp_subtree:
            continue
        if node.type == "LLM" and node.time is not None:
            total += node.time
    return total


def compute_tool_overhead(root: TraceNode) -> float:
    """Compute global Tool time (seconds) - CrewAI tools execute serially."""
    total = 0.0
    for node in iter_nodes(root):
        if node.in_mcp_subtree:
            continue
        if node.type == "Tool" and node.time is not None:
            total += node.time
    return total


def compute_a2a_overhead(root: TraceNode) -> float:
    """Compute A2A communication overhead: a2a_call_xxx - xxx_server_execution."""
    total = 0.0
    for node in iter_nodes(root):
        if node.in_mcp_subtree:
            continue
        if node.type == "SPAN" and node.name.startswith("a2a_call_"):
            if node.time is None:
                continue
            server = None
            for ch in node.children:
                if ch.type == "SPAN" and "server_execution" in ch.name:
                    server = ch
                    break
            if server is not None and server.time is not None:
                diff = node.time - server.time
                if diff > 0:
                    total += diff
    return total


def _sum_mcp_time(node: TraceNode) -> float:
    """Sum MCP time inside the given node's subtree."""
    total = 0.0
    stack = [node]
    while stack:
        n = stack.pop()
        if n is not node and n.in_mcp_subtree and n.time is not None:
            total += n.time
        for ch in n.children:
            stack.append(ch)
    return total


def _find_framework_child(server_node: TraceNode) -> Optional[TraceNode]:
    """Find the CrewAI kickoff node within a server_execution span."""
    for ch in server_node.children:
        if ch.type == "Chain" and re.match(r"Crew_.*\.kickoff", ch.name):
            return ch
    return None


def compute_server_overhead(root: TraceNode) -> float:
    """Compute server execution overhead: xxx_server_execution - Crew kickoff - MCP."""
    total = 0.0
    for node in iter_nodes(root):
        if node.in_mcp_subtree:
            continue
        if node.type == "SPAN" and "server_execution" in node.name:
            if node.time is None:
                continue
            framework = _find_framework_child(node)
            framework_time = (
                framework.time if framework and framework.time is not None else 0.0
            )
            mcp_time = _sum_mcp_time(node)
            diff = node.time - framework_time - mcp_time
            if diff > 0:
                total += diff
    return total


_FRAMEWORK_MAP: Optional[Dict[str, str]] = None


def _load_framework_map() -> Dict[str, str]:
    """Load framework mapping config (used for categorized statistics)."""
    global _FRAMEWORK_MAP
    if _FRAMEWORK_MAP is not None:
        return _FRAMEWORK_MAP

    cfg_path = Path(__file__).resolve().parent / "FRAMEWORK_map.yaml"
    if not cfg_path.exists():
        raise FileNotFoundError(
            f"Required framework mapping file not found: {cfg_path}"
        )

    try:
        with cfg_path.open("r", encoding="utf-8") as f:
            data = yaml.safe_load(f) or {}
    except Exception as e:
        raise RuntimeError(f"Failed to load FRAMEWORK_map.yaml: {e}") from e

    raw_map = data.get("framework_map", {})
    if not isinstance(raw_map, dict) or not raw_map:
        raise ValueError("FRAMEWORK_map.yaml must contain 'framework_map' dict")

    mapping: Dict[str, str] = {}
    for span_name, fw_name in raw_map.items():
        if not isinstance(span_name, str) or not isinstance(fw_name, str):
            continue
        key = span_name.strip()
        val = fw_name.strip().lower()
        if val in ("langgraph", "lang_graph", "lg"):
            bucket = "langgraph"
        elif val in ("autogen", "auto_gen", "auto-gen"):
            bucket = "autogen"
        elif val in ("crewai", "crew", "crew_ai"):
            bucket = "crew"
        else:
            raise ValueError(f"Unsupported framework: {fw_name} for {span_name}")
        mapping[key] = bucket

    _FRAMEWORK_MAP = mapping
    return mapping


def _normalize_business_span_name(name: str) -> str:
    """Normalize business SPAN name (remove business_retry marker)."""
    name = re.sub(r"\s*\(business_retry\s+\d+\)$", "", name)
    return name.strip()


def _categorize_framework_bucket(node: TraceNode) -> str:
    """Determine framework bucket based on the business SPAN (for categorized stats)."""
    framework_map = _load_framework_map()

    # Walk upwards to locate the a2a_call_xxx parent node
    p = node.parent
    business_name: Optional[str] = None
    while p is not None:
        if p.type == "SPAN" and p.name.startswith("a2a_call_"):
            business_name = _normalize_business_span_name(p.name)
            break
        p = p.parent

    if not business_name:
        raise RuntimeError(
            f"Failed to locate business SPAN for framework node '{node.name}'"
        )

    bucket = framework_map.get(business_name)
    if bucket not in ("langgraph", "crew", "autogen"):
        raise KeyError(
            f"No framework mapping found for business SPAN '{business_name}' in FRAMEWORK_map.yaml"
        )

    return bucket


def compute_framework_breakdown(root: TraceNode) -> Tuple[float, float, float]:
    """Compute orchestration overhead per framework bucket (for categorized stats).

    Returns:
        (langgraph_total, crew_total, autogen_total)
    """
    lg_total = 0.0
    crew_total = 0.0
    autogen_total = 0.0

    for node in iter_nodes(root):
        if node.in_mcp_subtree or node.time is None:
            continue
        if node.type == "Chain" and re.match(r"Crew_.*\.kickoff", node.name):
            children_time = sum(
                (ch.time or 0.0) for ch in node.children if not ch.in_mcp_subtree
            )
            diff = node.time - children_time
            if diff > 0:
                # Bucket by the business SPAN
                bucket = _categorize_framework_bucket(node)
                if bucket == "langgraph":
                    lg_total += diff
                elif bucket == "autogen":
                    autogen_total += diff
                else:
                    crew_total += diff

    return lg_total, crew_total, autogen_total


def compute_framework_overhead(root: TraceNode) -> float:
    """Return total framework overhead (kept for backward compatibility)."""
    lg_total, crew_total, autogen_total = compute_framework_breakdown(root)
    return lg_total + crew_total + autogen_total


def analyze_file(path: Path) -> Optional[Dict[str, float]]:
    parser = ExecutionTreeParser(str(path))
    root = parser.parse()
    if root is None:
        return None

    orch = find_orchestrator(root)
    total_time_s = orch.time if orch.time is not None else None
    if total_time_s is None or total_time_s <= 0:
        return None

    # All internal computations use seconds (s)
    llm_s = compute_llm_overhead(root)
    tool_s = compute_tool_overhead(root)
    a2a_s = compute_a2a_overhead(root)
    lg_fw_s, crew_fw_s, autogen_fw_s = compute_framework_breakdown(root)
    framework_s = lg_fw_s + crew_fw_s + autogen_fw_s
    server_s = compute_server_overhead(root)
    retry_s = compute_retry_time(root)

    classified_s = llm_s + tool_s + a2a_s + framework_s + server_s
    residual_s = total_time_s - classified_s

    # Compute ratios in seconds first
    llm_ratio = llm_s / total_time_s
    tool_ratio = tool_s / total_time_s
    a2a_ratio = a2a_s / total_time_s
    framework_ratio = framework_s / total_time_s
    server_ratio = server_s / total_time_s
    residual_ratio = residual_s / total_time_s
    retry_ratio = retry_s / total_time_s if total_time_s > 0 else 0.0

    # Convert to milliseconds (integer ms) for CSV output
    def to_ms(x: float) -> int:
        return int(round(x * 1000.0))

    total_time = to_ms(total_time_s)
    llm = to_ms(llm_s)
    tool = to_ms(tool_s)
    a2a = to_ms(a2a_s)
    lg_fw = to_ms(lg_fw_s)
    crew_fw = to_ms(crew_fw_s)
    autogen_fw = to_ms(autogen_fw_s)
    framework = lg_fw + crew_fw + autogen_fw
    server = to_ms(server_s)
    retry_time = to_ms(retry_s)
    classified = llm + tool + a2a + framework + server
    residual = total_time - classified

    result: Dict[str, float] = {
        "model": parser.model or "",
        "project": parser.project or "",
        "session_id": parser.session_id,
        "orchestrator_time": total_time,
        "LLM_OVERHEAD": llm,
        "Tool_OVERHEAD": tool,
        "A2A_OVERHEAD": a2a,
        "Framework_OVERHEAD": framework,
        "LangGraph_Framework_OVERHEAD": lg_fw,
        "CrewAI_Framework_OVERHEAD": crew_fw,
        "AutoGen_Framework_OVERHEAD": autogen_fw,
        "Server_OVERHEAD": server,
        "retry_time_ms": retry_time,
        "total_classified": classified,
        "residual": residual,
    }

    result.update(
        {
            "LLM_ratio": llm_ratio,
            "Tool_ratio": tool_ratio,
            "A2A_ratio": a2a_ratio,
            "Framework_ratio": framework_ratio,
            "Server_ratio": server_ratio,
            "residual_ratio": residual_ratio,
            "retry_ratio_vs_orch": retry_ratio,
        }
    )

    return result


def find_results_root() -> Path:
    p = Path(__file__).resolve()
    for parent in p.parents:
        if parent.name == "RESULTS":
            return parent
    return p.parent.parent.parent


def collect_execution_paths(results_dir: Path, project_name: str) -> List[Path]:
    paths: List[Path] = []
    for model_dir in results_dir.iterdir():
        if not model_dir.is_dir():
            continue
        proj_dir = model_dir / project_name / "test_results"
        if not proj_dir.exists():
            continue
        for session_dir in proj_dir.iterdir():
            if not session_dir.is_dir():
                continue
            ep = session_dir / "execution_path.md"
            if ep.exists():
                paths.append(ep)
    paths.sort()
    return paths


def write_model_summary(rows: List[Dict[str, float]], out_path: Path) -> None:
    """Aggregate per-run breakdown results by model and write a summary CSV."""
    agg = defaultdict(
        lambda: {
            "count": 0,
            "total_orchestrator_time": 0.0,
            "total_LLM_OVERHEAD": 0.0,
            "total_Tool_OVERHEAD": 0.0,
            "total_A2A_OVERHEAD": 0.0,
            "total_Framework_OVERHEAD": 0.0,
            "total_LangGraph_Framework_OVERHEAD": 0.0,
            "total_CrewAI_Framework_OVERHEAD": 0.0,
            "total_AutoGen_Framework_OVERHEAD": 0.0,
            "total_Server_OVERHEAD": 0.0,
            "total_retry_time_ms": 0.0,
            "total_classified": 0.0,
            "total_residual": 0.0,
        }
    )

    for row in rows:
        model = str(row.get("model", ""))
        m = agg[model]
        m["count"] += 1
        m["total_orchestrator_time"] += float(row.get("orchestrator_time", 0.0))
        m["total_LLM_OVERHEAD"] += float(row.get("LLM_OVERHEAD", 0.0))
        m["total_Tool_OVERHEAD"] += float(row.get("Tool_OVERHEAD", 0.0))
        m["total_A2A_OVERHEAD"] += float(row.get("A2A_OVERHEAD", 0.0))
        m["total_Framework_OVERHEAD"] += float(row.get("Framework_OVERHEAD", 0.0))
        m["total_LangGraph_Framework_OVERHEAD"] += float(
            row.get("LangGraph_Framework_OVERHEAD", 0.0)
        )
        m["total_CrewAI_Framework_OVERHEAD"] += float(
            row.get("CrewAI_Framework_OVERHEAD", 0.0)
        )
        m["total_AutoGen_Framework_OVERHEAD"] += float(
            row.get("AutoGen_Framework_OVERHEAD", 0.0)
        )
        m["total_Server_OVERHEAD"] += float(row.get("Server_OVERHEAD", 0.0))
        m["total_retry_time_ms"] += float(row.get("retry_time_ms", 0.0))
        m["total_classified"] += float(row.get("total_classified", 0.0))
        m["total_residual"] += float(row.get("residual", 0.0))

    summary_rows: List[Dict[str, float]] = []
    retry_rows: List[Dict[str, float]] = []

    for model, m in sorted(agg.items(), key=lambda kv: kv[0]):
        total_time = m["total_orchestrator_time"] or 1e-9

        llm = m["total_LLM_OVERHEAD"]
        tool = m["total_Tool_OVERHEAD"]
        a2a = m["total_A2A_OVERHEAD"]
        framework = m["total_Framework_OVERHEAD"]
        lg_fw = m["total_LangGraph_Framework_OVERHEAD"]
        crew_fw = m["total_CrewAI_Framework_OVERHEAD"]
        autogen_fw = m["total_AutoGen_Framework_OVERHEAD"]
        server = m["total_Server_OVERHEAD"]
        residual = m["total_residual"]
        retry_total = m["total_retry_time_ms"]

        components_time = llm + tool + a2a + framework + server + residual
        denom = components_time or 1e-9

        llm_share = llm / denom
        tool_share = tool / denom
        a2a_share = a2a / denom
        framework_share = framework / denom
        lg_share = lg_fw / denom
        crew_share = crew_fw / denom
        autogen_share = autogen_fw / denom
        server_share = server / denom
        residual_share = residual / denom

        retry_share_vs_orch = retry_total / (total_time or 1e-9)

        sum_component_shares = (
            llm_share
            + tool_share
            + a2a_share
            + framework_share
            + server_share
            + residual_share
        )

        summary_rows.append(
            {
                "model": model,
                "count": m["count"],
                "total_orchestrator_time": total_time,
                "total_LLM_OVERHEAD": llm,
                "total_Tool_OVERHEAD": tool,
                "total_A2A_OVERHEAD": a2a,
                "total_Framework_OVERHEAD": framework,
                "total_LangGraph_Framework_OVERHEAD": lg_fw,
                "total_CrewAI_Framework_OVERHEAD": crew_fw,
                "total_AutoGen_Framework_OVERHEAD": autogen_fw,
                "total_Server_OVERHEAD": server,
                "total_retry_time_ms": retry_total,
                "total_classified": m["total_classified"],
                "total_residual": residual,
                "total_components_time": components_time,
                "LLM_share": llm_share,
                "Tool_share": tool_share,
                "A2A_share": a2a_share,
                "Framework_share": framework_share,
                "LangGraph_Framework_share": lg_share,
                "CrewAI_Framework_share": crew_share,
                "AutoGen_Framework_share": autogen_share,
                "Server_share": server_share,
                "residual_share": residual_share,
                "retry_share_vs_orch": retry_share_vs_orch,
                "sum_component_shares": sum_component_shares,
            }
        )

        retry_rows.append(
            {
                "model": model,
                "count": m["count"],
                "total_orchestrator_time_ms": total_time,
                "total_retry_time_ms": retry_total,
                "retry_share_vs_orch": retry_share_vs_orch,
            }
        )

    if not summary_rows:
        return

    # Main per-model summary table
    fieldnames = list(summary_rows[0].keys())
    with out_path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(summary_rows)

    # RETRY cost summary table
    if retry_rows:
        retry_out_path = out_path.with_name("retry_breakdown_summary_by_model.csv")
        retry_fieldnames = list(retry_rows[0].keys())
        with retry_out_path.open("w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=retry_fieldnames)
            writer.writeheader()
            writer.writerows(retry_rows)


def _normalize_crewai_agent_name(name: str) -> str:
    """Normalize CrewAI agent name by stripping the trailing ._execute_core."""
    name = re.sub(r"\._execute_core\]?$", "", name)
    return name.strip()


def collect_agent_llm_tool_breakdown(exec_paths: List[Path]) -> List[Dict[str, float]]:
    """Aggregate LLM/Tool time (ms) by (model, framework, agent_name).

    CrewAI: use direct child [AGENT] xxx._execute_core under [Chain] Crew***.kickoff as the container.
    """
    agg = defaultdict(
        lambda: {
            "llm_s": 0.0,
            "tool_s": 0.0,
            "occurrences": 0,
        }
    )

    for ep in exec_paths:
        parser = ExecutionTreeParser(str(ep))
        root = parser.parse()
        if root is None:
            continue
        model = parser.model or ""

        for node in iter_nodes(root):
            if node.in_mcp_subtree:
                continue
            # CrewAI: each direct child AGENT under kickoff is treated as an agent
            if node.type == "Chain" and re.match(r"Crew_.*\.kickoff", node.name):
                for ch in node.children:
                    if ch.in_mcp_subtree or ch.type != "AGENT":
                        continue
                    framework = "CrewAI"
                    agent_name = _normalize_crewai_agent_name(ch.name)
                    llm_s = compute_llm_overhead_for_subtree(ch)
                    tool_s = compute_tool_overhead_for_subtree(ch)
                    if llm_s == 0.0 and tool_s == 0.0:
                        continue
                    key = (model, framework, agent_name)
                    m = agg[key]
                    m["llm_s"] += llm_s
                    m["tool_s"] += tool_s
                    m["occurrences"] += 1

    rows: List[Dict[str, float]] = []
    for (model, framework, agent_name), st in sorted(
        agg.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[0][2])
    ):
        llm_ms = int(round(st["llm_s"] * 1000.0))
        tool_ms = int(round(st["tool_s"] * 1000.0))
        total_ms = llm_ms + tool_ms
        denom = total_ms or 1e-9
        rows.append(
            {
                "model": model,
                "framework": framework,
                "agent_name": agent_name,
                "occurrences": st["occurrences"],
                "total_llm_time_ms": llm_ms,
                "total_tool_time_ms": tool_ms,
                "total_agent_llm_tool_time_ms": total_ms,
                "llm_share_in_agent": llm_ms / denom,
                "tool_share_in_agent": tool_ms / denom,
            }
        )

    return rows


def main() -> None:
    results_dir = find_results_root()
    project_name = "RecruitmentAssistant-A2A"
    exec_paths = collect_execution_paths(results_dir, project_name)

    print(f"Found {len(exec_paths)} execution_path.md files")

    rows: List[Dict[str, float]] = []

    for ep in exec_paths:
        print(f"  Processing: {ep.parent.parent.parent.name}/{ep.parent.name}")
        metrics = analyze_file(ep)
        if metrics is not None:
            rows.append(metrics)

    out_dir = Path(__file__).resolve().parent
    per_run_path = out_dir / "performance_breakdown_summary.csv"
    per_model_path = out_dir / "performance_breakdown_summary_by_model.csv"
    agent_path = out_dir / "agent_llm_tool_breakdown_by_model.csv"

    if rows:
        # Per-run detailed table (one row per run)
        fieldnames = list(rows[0].keys())
        with per_run_path.open("w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(rows)
        print(f"\nWrote per-run breakdown to {per_run_path.name}")

        # Per-model aggregation
        write_model_summary(rows, per_model_path)
        print(f"Wrote per-model summary to {per_model_path.name}")

        # Agent-level LLM/Tool breakdown
        agent_rows = collect_agent_llm_tool_breakdown(exec_paths)
        if agent_rows:
            agent_fieldnames = list(agent_rows[0].keys())
            with agent_path.open("w", newline="", encoding="utf-8") as f:
                writer = csv.DictWriter(f, fieldnames=agent_fieldnames)
                writer.writeheader()
                writer.writerows(agent_rows)
            print(f"Wrote agent LLM/Tool breakdown to {agent_path.name}")

        print("\nDone:")
        print(f"  - Processed {len(rows)} valid samples")
        print("  - 5 components: LLM/Tool/A2A/Framework(CrewAI)/Server")
    else:
        print("No valid execution_path.md files found")


if __name__ == "__main__":
    main()