diff --git a/README.md b/README.md
index 1656246..33fadca 100644
--- a/README.md
+++ b/README.md
@@ -163,16 +163,6 @@ This is useful for:
 - Monitoring API usage and performance
 - Learning how the multi-agent system orchestrates tasks
 
-### Live Observability Monitor
-
-For real-time visual monitoring of agent execution with interactive profiling:
-
-```bash
-./observability/live_monitor.sh
-```
-
-This launches a web-based profiler that automatically tracks your current session, displaying tool calls, timing metrics, and agent interactions in real-time. The visualization updates live as your agents work, providing an interactive dashboard for monitoring pipeline execution and performance analysis.
-
 The pipeline will:
 1. Scan for services (Cargo.toml, go.mod, package.json, pyproject.toml files)
 2. Build dependency graph
diff --git a/agent/callbacks_langgraph_legacy.py b/agent/callbacks_langgraph_legacy.py
deleted file mode 100644
index ed079db..0000000
--- a/agent/callbacks_langgraph_legacy.py
+++ /dev/null
@@ -1,869 +0,0 @@
-"""LangGraph callback handlers for agent lifecycle tracking.
-
-Provides LangChain-compatible callback handlers that track:
-- Tool calls (start, end, error)
-- LLM/chat model invocations
-- Subagent lifecycle (spawn, complete)
-- Graph node transitions (for LangGraph visualization)
-- Token usage metrics
-
-These callbacks write structured JSONL logs for real-time visualization
-in the session_profiler.html dashboard.
-"""
-
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
-from uuid import UUID
-
-from langchain_core.callbacks import BaseCallbackHandler
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.messages import BaseMessage
-from langchain_core.outputs import LLMResult
-
-from agent.utils.transcript import TranscriptWriter
-
-logger = logging.getLogger(__name__)
-
-
-class FlashlightCallbackHandler(BaseCallbackHandler):
-    """Callback handler that tracks tool usage, subagent lifecycle, and LLM calls.
-
-    Provides comprehensive observability for LangGraph-based agent systems:
-    - Tool call tracking with timing and context weight estimation
-    - Subagent spawn/complete lifecycle events
-    - LLM invocation tracking with token usage
-    - Graph node transition events for visualization
-
-    Writes structured JSONL logs compatible with the session_profiler.html dashboard.
-    """
-
-    def __init__(
-        self,
-        transcript_writer: Optional[TranscriptWriter] = None,
-        session_dir: Optional[Path] = None,
-        verbose: bool = False,
-    ):
-        self.transcript_writer = transcript_writer
-        self.verbose = verbose
-
-        # Active subagent context
-        self._current_subagent_type: Optional[str] = None
-        self._current_subagent_id: Optional[str] = None
-        self._current_description: Optional[str] = None
-
-        # Current graph node context
-        self._current_graph_node: Optional[str] = None
-        self._graph_run_id: Optional[str] = None
-
-        # Counters
-        self.subagent_counters: Dict[str, int] = {}
-        self.active_code_analyzers: int = 0
-        self.api_call_count: int = 0
-        self.tool_call_count: int = 0
-
-        # Token usage tracking
-        self.total_input_tokens: int = 0
-        self.total_output_tokens: int = 0
-        self.total_cache_read_tokens: int = 0
-        self.total_cache_creation_tokens: int = 0
-
-        # Subagent tracking
-        self._subagent_sessions: Dict[str, Dict[str, Any]] = {}
-
-        # Active tool calls (for timing)
-        self._active_tool_calls: Dict[str, datetime] = {}
-
-        # Active LLM calls (for correlating start->complete with reasoning patterns)
-        self._active_llm_calls: Dict[str, Dict[str, Any]] = {}
-
-        # Tool call detail log (JSONL format)
-        self.tool_log_file = None
-        if session_dir:
-            tool_log_path = session_dir / "tool_calls.jsonl"
-            self.tool_log_file = open(tool_log_path, "w", encoding="utf-8")
-
-    # ------------------------------------------------------------------
-    # Subagent context management
-    # ------------------------------------------------------------------
-
-    def set_subagent_context(
-        self,
-        subagent_type: str,
-        description: str,
-    ) -> str:
-        """Set the current subagent context and return a generated ID.
-
-        Called by the graph when spawning a subagent node.
-
-        Returns:
-            Generated subagent ID (e.g., "CODE-LIBRARY-ANALYZER-3").
-        """
-        self.subagent_counters.setdefault(subagent_type, 0)
-        self.subagent_counters[subagent_type] += 1
-        subagent_id = f"{subagent_type.upper()}-{self.subagent_counters[subagent_type]}"
-
-        self._current_subagent_type = subagent_type
-        self._current_subagent_id = subagent_id
-        self._current_description = description
-
-        if subagent_type == "application-analyzer":
-            self.active_code_analyzers += 1
-
-        session = {
-            "subagent_type": subagent_type,
-            "subagent_id": subagent_id,
-            "description": description,
-            "spawned_at": datetime.now().isoformat(),
-            "tool_calls": 0,
-            "api_calls": 0,
-        }
-        self._subagent_sessions[subagent_id] = session
-
-        print(f"{'=' * 60}")
-        print(f"SUBAGENT SPAWNED: {subagent_id}")
-        print(f"{'=' * 60}")
-        print(f"Task: {description}")
-        print(f"Type: {subagent_type}")
-        print(f"{'=' * 60}")
-
-        self._log_to_jsonl(
-            {
-                "event": "subagent_spawn",
-                "timestamp": session["spawned_at"],
-                "subagent_id": subagent_id,
-                "subagent_type": subagent_type,
-                "description": description,
-            }
-        )
-
-        return subagent_id
-
-    def clear_subagent_context(self) -> None:
-        """Clear subagent context after subagent completes."""
-        if self._current_subagent_id:
-            session = self._subagent_sessions.get(self._current_subagent_id, {})
-            completed_at = datetime.now().isoformat()
-            session["completed_at"] = completed_at
-
-            # Calculate duration
-            spawned_at = session.get("spawned_at", "")
-            if spawned_at:
-                start = datetime.fromisoformat(spawned_at)
-                end = datetime.fromisoformat(completed_at)
-                secs = int((end - start).total_seconds())
-                duration_str = f"{secs // 60:02d}:{secs % 60:02d}"
-            else:
-                duration_str = "??:??"
-
-            print(f"{'=' * 60}")
-            print(f"SUBAGENT COMPLETED: {self._current_subagent_id}")
-            print(f"{'=' * 60}")
-            print(f"Task: {self._current_description}")
-            print(f"Duration: {duration_str}")
-            print(f"Tool calls: {session.get('tool_calls', 0)}")
-            print(f"{'=' * 60}")
-
-            self._log_to_jsonl(
-                {
-                    "event": "subagent_complete",
-                    "timestamp": completed_at,
-                    "subagent_id": self._current_subagent_id,
-                    "subagent_type": self._current_subagent_type,
-                    "description": self._current_description,
-                    "duration": duration_str,
-                    "tool_calls": session.get("tool_calls", 0),
-                }
-            )
-
-            # Handle application-analyzer completion signals
-            if self._current_subagent_type == "application-analyzer":
-                self.active_code_analyzers -= 1
-                if self.transcript_writer:
-                    self.transcript_writer.write_to_file(
-                        f"[APPLICATION_ANALYSIS_COMPLETE] {self._current_description}\n"
-                    )
-                    if self.active_code_analyzers == 0:
-                        self.transcript_writer.write_to_file(
-                            "[ALL_APPLICATION_ANALYSIS_COMPLETE]\n"
-                        )
-
-        self._current_subagent_type = None
-        self._current_subagent_id = None
-        self._current_description = None
-
-    # ------------------------------------------------------------------
-    # LangChain callback methods
-    # ------------------------------------------------------------------
-
-    def on_llm_start(
-        self,
-        serialized: Optional[Dict[str, Any]],
-        prompts: List[str],
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when LLM starts generating (non-chat/completion models)."""
-        if serialized is None:
-            serialized = {}
-
-        self.api_call_count += 1
-        agent_label = self._current_subagent_id or "LEAD AGENT"
-        print(f"\n[LLM CALL #{self.api_call_count}] {agent_label}", flush=True)
-
-        if self._current_subagent_id:
-            session = self._subagent_sessions.get(self._current_subagent_id, {})
-            session["api_calls"] = session.get("api_calls", 0) + 1
-
-        # Analyze prompts for reasoning pattern (non-chat format)
-        reasoning_pattern = self._analyze_prompt_reasoning_pattern(prompts, kwargs)
-
-        # Store for correlation with llm_end
-        self._active_llm_calls[str(run_id)] = {
-            "reasoning_pattern": reasoning_pattern,
-            "start_time": datetime.now(),
-        }
-
-        # Log LLM start event
-        self._log_to_jsonl(
-            {
-                "event": "llm_start",
-                "timestamp": datetime.now().isoformat(),
-                "run_id": str(run_id),
-                "parent_run_id": str(parent_run_id) if parent_run_id else None,
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "agent_type": self._current_subagent_type or "lead",
-                "graph_node": self._current_graph_node,
-                "reasoning_pattern": reasoning_pattern,
-                "model": serialized.get("kwargs", {}).get("model_name", "unknown"),
-                "llm_type": "completion",  # Non-chat model
-            }
-        )
-
-    def on_chat_model_start(
-        self,
-        serialized: Optional[Dict[str, Any]],
-        messages: List[List[BaseMessage]],
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when chat model starts generating."""
-        if serialized is None:
-            serialized = {}
-
-        self.api_call_count += 1
-        agent_label = self._current_subagent_id or "LEAD AGENT"
-        print(f"\n[LLM CALL #{self.api_call_count}] {agent_label}", flush=True)
-
-        if self._current_subagent_id:
-            session = self._subagent_sessions.get(self._current_subagent_id, {})
-            session["api_calls"] = session.get("api_calls", 0) + 1
-
-        # Analyze message structure for reasoning pattern detection
-        reasoning_pattern = self._analyze_reasoning_pattern(messages, kwargs)
-
-        # Store reasoning pattern for correlation with llm_complete
-        self._active_llm_calls[str(run_id)] = {
-            "reasoning_pattern": reasoning_pattern,
-            "start_time": datetime.now(),
-        }
-
-        # Log LLM call start with reasoning context
-        self._log_to_jsonl(
-            {
-                "event": "llm_start",
-                "timestamp": datetime.now().isoformat(),
-                "run_id": str(run_id),
-                "parent_run_id": str(parent_run_id) if parent_run_id else None,
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "agent_type": self._current_subagent_type or "lead",
-                "graph_node": self._current_graph_node,
-                "reasoning_pattern": reasoning_pattern,
-                "model": serialized.get("kwargs", {}).get("model_name", "unknown"),
-            }
-        )
-
-    def _analyze_reasoning_pattern(
-        self,
-        messages: List[List[BaseMessage]],
-        kwargs: Dict[str, Any],
-    ) -> Dict[str, Any]:
-        """Analyze message structure to infer reasoning pattern.
-
-        Patterns detected:
-        - one_shot: Single user message, no prior context
-        - multi_turn: Multiple back-and-forth exchanges
-        - chain_of_thought: System prompt contains CoT instructions or prior reasoning
-        - react: Tool use loop (agent -> tool -> agent pattern)
-        - tree_of_thought: Multiple parallel branches or backtracking
-        - self_reflection: Model critiquing/refining its own output
-        """
-        pattern = {
-            "type": "one_shot",
-            "turn_count": 0,
-            "tool_results_in_context": 0,
-            "has_system_prompt": False,
-            "has_cot_instructions": False,
-            "has_prior_assistant_messages": False,
-            "context_window_estimate": 0,
-        }
-
-        if not messages or not messages[0]:
-            return pattern
-
-        msg_list = messages[0]  # First batch of messages
-        pattern["turn_count"] = len(msg_list)
-
-        # Count message types
-        system_count = 0
-        user_count = 0
-        assistant_count = 0
-        tool_count = 0
-
-        total_content_length = 0
-        cot_keywords = [
-            "step by step",
-            "think through",
-            "reasoning",
-            "let's think",
-            "chain of thought",
-            "analyze",
-        ]
-
-        for msg in msg_list:
-            msg_type = type(msg).__name__
-            content = ""
-
-            if hasattr(msg, "content"):
-                if isinstance(msg.content, str):
-                    content = msg.content
-                elif isinstance(msg.content, list):
-                    content = " ".join(str(block) for block in msg.content)
-
-            total_content_length += len(content)
-            content_lower = content.lower()
-
-            if msg_type == "SystemMessage":
-                system_count += 1
-                pattern["has_system_prompt"] = True
-                # Check for CoT instructions in system prompt
-                if any(kw in content_lower for kw in cot_keywords):
-                    pattern["has_cot_instructions"] = True
-
-            elif msg_type == "HumanMessage":
-                user_count += 1
-
-            elif msg_type == "AIMessage":
-                assistant_count += 1
-                pattern["has_prior_assistant_messages"] = True
-                # Check for tool calls in assistant messages
-                if hasattr(msg, "tool_calls") and msg.tool_calls:
-                    tool_count += len(msg.tool_calls)
-
-            elif msg_type == "ToolMessage":
-                tool_count += 1
-                pattern["tool_results_in_context"] += 1
-
-        # Estimate context window usage (rough: 1 token ≈ 4 chars)
-        pattern["context_window_estimate"] = total_content_length // 4
-
-        # Determine reasoning pattern type
-        if tool_count > 0 and assistant_count > 0:
-            # ReAct pattern: interleaved reasoning and tool use
-            pattern["type"] = "react"
-            if tool_count >= 3:
-                pattern["type"] = "react_multi_step"
-        elif assistant_count >= 2:
-            # Multiple assistant messages could indicate self-reflection or tree-of-thought
-            if pattern["has_cot_instructions"]:
-                pattern["type"] = "chain_of_thought"
-            else:
-                pattern["type"] = "multi_turn"
-        elif pattern["has_cot_instructions"]:
-            pattern["type"] = "chain_of_thought"
-        elif user_count > 1:
-            pattern["type"] = "multi_turn"
-        else:
-            pattern["type"] = "one_shot"
-
-        return pattern
-
-    def _analyze_prompt_reasoning_pattern(
-        self,
-        prompts: List[str],
-        kwargs: Dict[str, Any],
-    ) -> Dict[str, Any]:
-        """Analyze raw prompt strings for reasoning pattern (non-chat LLM calls).
-
-        This is used for completion-style models that receive prompts as strings
-        rather than structured message lists.
-        """
-        pattern = {
-            "type": "one_shot",
-            "turn_count": len(prompts),
-            "tool_results_in_context": 0,
-            "has_system_prompt": False,
-            "has_cot_instructions": False,
-            "has_prior_assistant_messages": False,
-            "context_window_estimate": 0,
-            "llm_type": "completion",
-        }
-
-        if not prompts:
-            return pattern
-
-        total_content = " ".join(prompts)
-        total_length = len(total_content)
-        content_lower = total_content.lower()
-
-        # Estimate context window
-        pattern["context_window_estimate"] = total_length // 4
-
-        # Check for CoT/reasoning indicators in the prompt
-        cot_keywords = [
-            "step by step",
-            "think through",
-            "reasoning",
-            "let's think",
-            "chain of thought",
-            "analyze carefully",
-            "break down",
-        ]
-        if any(kw in content_lower for kw in cot_keywords):
-            pattern["has_cot_instructions"] = True
-            pattern["type"] = "chain_of_thought"
-
-        # Check for tool/function patterns (may appear in raw prompts)
-        tool_indicators = [
-            "tool_result",
-            "function_call",
-            "tool_call",
-            "<tool>",
-            "</tool>",
-            "observation:",
-            "action:",
-        ]
-        tool_matches = sum(1 for ind in tool_indicators if ind in content_lower)
-        if tool_matches >= 2:
-            pattern["tool_results_in_context"] = tool_matches
-            pattern["type"] = "react"
-            if tool_matches >= 4:
-                pattern["type"] = "react_multi_step"
-
-        # Check for multi-turn indicators
-        turn_indicators = ["human:", "assistant:", "user:", "ai:"]
-        turn_matches = sum(1 for ind in turn_indicators if ind in content_lower)
-        if turn_matches >= 2 and pattern["type"] == "one_shot":
-            pattern["type"] = "multi_turn"
-            pattern["has_prior_assistant_messages"] = True
-
-        return pattern
-
-    def on_tool_start(
-        self,
-        serialized: Optional[Dict[str, Any]],
-        input_str: str,
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        inputs: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when a tool starts executing."""
-        if serialized is None:
-            serialized = {}
-
-        self.tool_call_count += 1
-        tool_name = serialized.get("name", "unknown")
-        agent_label = self._current_subagent_id or "LEAD AGENT"
-        start_time = datetime.now()
-
-        # Track start time for duration calculation
-        self._active_tool_calls[str(run_id)] = start_time
-
-        # Extract meaningful detail for console
-        detail = self._get_tool_detail(tool_name, inputs)
-        message = f"[{agent_label}] -> {tool_name}"
-        if detail:
-            message += f" {detail}"
-
-        logger.info(message)
-        if self.transcript_writer:
-            self.transcript_writer.write(f"\n{message}")
-
-        if self._current_subagent_id:
-            session = self._subagent_sessions.get(self._current_subagent_id, {})
-            session["tool_calls"] = session.get("tool_calls", 0) + 1
-
-        # Parse tool input for structured logging
-        tool_input = {}
-        if inputs:
-            tool_input = inputs
-        elif input_str:
-            try:
-                import ast
-
-                tool_input = (
-                    ast.literal_eval(input_str)
-                    if input_str.startswith("{")
-                    else {"input": input_str}
-                )
-            except (ValueError, SyntaxError):
-                tool_input = {"input": input_str[:200]}
-
-        self._log_to_jsonl(
-            {
-                "event": "tool_call_start",
-                "timestamp": start_time.isoformat(),
-                "tool_use_id": str(run_id),
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "agent_type": self._current_subagent_type or "lead",
-                "graph_node": self._current_graph_node,
-                "tool_name": tool_name,
-                "tool_input": tool_input,
-                "input_preview": str(input_str)[:200] if input_str else "",
-            }
-        )
-
-    def on_tool_end(
-        self,
-        output: Any,
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when a tool finishes executing."""
-        end_time = datetime.now()
-
-        # Calculate duration
-        start_time = self._active_tool_calls.pop(str(run_id), None)
-        duration_ms = None
-        if start_time:
-            duration_ms = (end_time - start_time).total_seconds() * 1000
-
-        # Handle different output types: str, ToolMessage, or other objects
-        if output is None:
-            output_size = 0
-        elif isinstance(output, str):
-            output_size = len(output)
-        elif hasattr(output, "content"):
-            # Handle ToolMessage and similar message objects
-            output_size = len(output.content) if output.content else 0
-        else:
-            # Fallback: convert to string and measure
-            output_size = len(str(output))
-
-        self._log_to_jsonl(
-            {
-                "event": "tool_call_complete",
-                "timestamp": end_time.isoformat(),
-                "tool_use_id": str(run_id),
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "agent_type": self._current_subagent_type or "lead",
-                "output_size": output_size,
-                "duration_ms": duration_ms,
-                "success": True,
-            }
-        )
-
-    def on_tool_error(
-        self,
-        error: BaseException,
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when a tool errors."""
-        end_time = datetime.now()
-        agent_label = self._current_subagent_id or "LEAD AGENT"
-        logger.warning(f"[{agent_label}] Tool error: {error}")
-
-        # Calculate duration
-        start_time = self._active_tool_calls.pop(str(run_id), None)
-        duration_ms = None
-        if start_time:
-            duration_ms = (end_time - start_time).total_seconds() * 1000
-
-        self._log_to_jsonl(
-            {
-                "event": "tool_call_error",
-                "timestamp": end_time.isoformat(),
-                "tool_use_id": str(run_id),
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "agent_type": self._current_subagent_type or "lead",
-                "duration_ms": duration_ms,
-                "error": str(error),
-            }
-        )
-
-    def on_llm_end(
-        self,
-        response: LLMResult,
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when LLM finishes generating."""
-        end_time = datetime.now()
-
-        # Retrieve reasoning pattern from correlated llm_start
-        llm_call_data = self._active_llm_calls.pop(str(run_id), {})
-        reasoning_pattern = llm_call_data.get("reasoning_pattern", {})
-        start_time = llm_call_data.get("start_time")
-
-        # Calculate LLM call duration
-        duration_ms = None
-        if start_time:
-            duration_ms = (end_time - start_time).total_seconds() * 1000
-
-        # Extract token usage from LLM response
-        llm_output = response.llm_output or {}
-        token_usage = llm_output.get("token_usage", {})
-
-        # Handle different token usage formats (OpenAI, Anthropic via OpenRouter, etc.)
-        input_tokens = token_usage.get("prompt_tokens", 0) or token_usage.get(
-            "input_tokens", 0
-        )
-        output_tokens = token_usage.get("completion_tokens", 0) or token_usage.get(
-            "output_tokens", 0
-        )
-        cache_read = token_usage.get("cache_read_input_tokens", 0)
-        cache_creation = token_usage.get("cache_creation_input_tokens", 0)
-
-        # Analyze response for reasoning indicators
-        response_analysis = self._analyze_llm_response(response)
-
-        # Update totals
-        self.total_input_tokens += input_tokens
-        self.total_output_tokens += output_tokens
-        self.total_cache_read_tokens += cache_read
-        self.total_cache_creation_tokens += cache_creation
-
-        # Log token usage event with reasoning analysis AND pattern (no correlation needed in dashboard)
-        self._log_to_jsonl(
-            {
-                "event": "llm_complete",
-                "timestamp": end_time.isoformat(),
-                "run_id": str(run_id),
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "agent_type": self._current_subagent_type or "lead",
-                "graph_node": self._current_graph_node,
-                "input_tokens": input_tokens,
-                "output_tokens": output_tokens,
-                "cache_read_tokens": cache_read,
-                "cache_creation_tokens": cache_creation,
-                "total_input_tokens": self.total_input_tokens,
-                "total_output_tokens": self.total_output_tokens,
-                "model": llm_output.get("model_name", "unknown"),
-                "response_analysis": response_analysis,
-                "reasoning_pattern": reasoning_pattern,
-                "duration_ms": duration_ms,
-            }
-        )
-
-        # Extract text content for transcript
-        if self.transcript_writer and response.generations:
-            for gen_list in response.generations:
-                for gen in gen_list:
-                    text = gen.text
-                    if text:
-                        self.transcript_writer.write_to_file(text)
-
-    def _analyze_llm_response(self, response: LLMResult) -> Dict[str, Any]:
-        """Analyze LLM response for reasoning pattern indicators.
-
-        Returns metrics about the response structure that help identify
-        the reasoning pattern used.
-        """
-        analysis = {
-            "has_tool_calls": False,
-            "tool_call_count": 0,
-            "has_thinking": False,
-            "thinking_length": 0,
-            "response_length": 0,
-            "output_type": "text",
-        }
-
-        if not response.generations:
-            return analysis
-
-        for gen_list in response.generations:
-            for gen in gen_list:
-                # Check for tool calls
-                if hasattr(gen, "message"):
-                    msg = gen.message
-                    if hasattr(msg, "tool_calls") and msg.tool_calls:
-                        analysis["has_tool_calls"] = True
-                        analysis["tool_call_count"] = len(msg.tool_calls)
-                        analysis["output_type"] = "tool_calls"
-
-                    # Check for thinking/reasoning blocks (Claude extended thinking)
-                    if hasattr(msg, "content") and isinstance(msg.content, list):
-                        for block in msg.content:
-                            if isinstance(block, dict):
-                                if block.get("type") == "thinking":
-                                    analysis["has_thinking"] = True
-                                    analysis["thinking_length"] = len(
-                                        block.get("thinking", "")
-                                    )
-                                elif block.get("type") == "text":
-                                    analysis["response_length"] += len(
-                                        block.get("text", "")
-                                    )
-                    elif hasattr(msg, "content") and isinstance(msg.content, str):
-                        analysis["response_length"] = len(msg.content)
-
-                # Fallback to gen.text
-                if gen.text:
-                    if analysis["response_length"] == 0:
-                        analysis["response_length"] = len(gen.text)
-
-        return analysis
-
-    # ------------------------------------------------------------------
-    # Graph node tracking (LangGraph integration)
-    # ------------------------------------------------------------------
-
-    def on_chain_start(
-        self,
-        serialized: Optional[Dict[str, Any]],
-        inputs: Dict[str, Any],
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when a chain/graph node starts execution."""
-        # Handle None serialized (can happen with some LangChain components)
-        if serialized is None:
-            serialized = {}
-
-        node_name = serialized.get("name", "unknown")
-        graph_id = serialized.get("graph", {}).get("id", str(run_id)[:8])
-
-        # Track graph run
-        if not self._graph_run_id:
-            self._graph_run_id = graph_id
-
-        self._current_graph_node = node_name
-
-        self._log_to_jsonl(
-            {
-                "event": "graph_node_start",
-                "timestamp": datetime.now().isoformat(),
-                "node_name": node_name,
-                "graph_id": graph_id,
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "run_id": str(run_id),
-                "parent_run_id": str(parent_run_id) if parent_run_id else None,
-            }
-        )
-
-        if self.verbose:
-            logger.info(f"[GRAPH] Node started: {node_name}")
-
-    def on_chain_end(
-        self,
-        outputs: Dict[str, Any],
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when a chain/graph node completes execution."""
-        node_name = self._current_graph_node or "unknown"
-
-        self._log_to_jsonl(
-            {
-                "event": "graph_node_end",
-                "timestamp": datetime.now().isoformat(),
-                "node_name": node_name,
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "run_id": str(run_id),
-            }
-        )
-
-        if self.verbose:
-            logger.info(f"[GRAPH] Node completed: {node_name}")
-
-    def on_chain_error(
-        self,
-        error: BaseException,
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Called when a chain/graph node errors."""
-        node_name = self._current_graph_node or "unknown"
-
-        self._log_to_jsonl(
-            {
-                "event": "graph_node_error",
-                "timestamp": datetime.now().isoformat(),
-                "node_name": node_name,
-                "agent_id": self._current_subagent_id or "MAIN_AGENT",
-                "run_id": str(run_id),
-                "error": str(error),
-            }
-        )
-
-        logger.error(f"[GRAPH] Node error in {node_name}: {error}")
-
-    # ------------------------------------------------------------------
-    # Helper methods
-    # ------------------------------------------------------------------
-
-    def _get_tool_detail(
-        self, tool_name: str, tool_input: Optional[Dict[str, Any]]
-    ) -> Optional[str]:
-        """Extract human-readable detail for specific tools."""
-        if not tool_input:
-            return None
-
-        if tool_name == "grep_files":
-            pattern = tool_input.get("pattern", "")
-            path = tool_input.get("path")
-            if path:
-                return f"`{pattern}` in {path}"
-            return f"`{pattern}`"
-
-        if tool_name in ("read_file", "write_file"):
-            fp = tool_input.get("file_path", "")
-            return fp
-
-        if tool_name == "glob_files":
-            return f"`{tool_input.get('pattern', '')}`"
-
-        if tool_name == "bash":
-            command = tool_input.get("command", "")
-            if len(command) > 80:
-                return f"`{command[:80]}...`"
-            return f"`{command}`"
-
-        return None
-
-    def _log_to_jsonl(self, log_entry: Dict[str, Any]) -> None:
-        """Write structured log entry to JSONL file."""
-        if self.tool_log_file:
-            self.tool_log_file.write(json.dumps(log_entry) + "\n")
-            self.tool_log_file.flush()
-
-    def close(self) -> None:
-        """Close the tool log file."""
-        if self.tool_log_file:
-            self.tool_log_file.close()
-            self.tool_log_file = None
diff --git a/agent/graph_langgraph_legacy.py b/agent/graph_langgraph_legacy.py
deleted file mode 100644
index 580f7b2..0000000
--- a/agent/graph_langgraph_legacy.py
+++ /dev/null
@@ -1,403 +0,0 @@
-"""LangGraph graph definitions for the flashlight multi-agent system.
-
-Architecture:
-    - Interactive Lead Agent via `build_lead_graph()` for CLI interaction
-    - Parallel Layer-Based Orchestration via `run_parallel_analysis()`
-    - Deterministic dispatch based on dependency graph topological layers
-    - All subagents within a layer execute in parallel
-    - Context accumulates between layers for dependency-aware analysis
-
-LLM calls are routed through OpenRouter (https://openrouter.ai/api/v1)
-using the OpenAI-compatible ChatOpenAI client. Set OPENROUTER_API_KEY
-in your environment.
-"""
-
-import logging
-import os
-from typing import Any, Dict, List, Literal, Optional
-
-from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph
-from langgraph.prebuilt import ToolNode
-
-from agent.callbacks import FlashlightCallbackHandler
-from agent.state import LeadAgentState, SubagentState
-from agent.tools import ANALYSIS_TOOLS, DOCUMENTER_TOOLS, LEAD_AGENT_TOOLS
-
-logger = logging.getLogger(__name__)
-
-# OpenRouter configuration
-OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
-DEFAULT_MODEL = os.environ.get("OPENROUTER_MODEL", "anthropic/claude-sonnet-4")
-
-
-# ---------------------------------------------------------------------------
-# LLM factory
-# ---------------------------------------------------------------------------
-
-
-def _make_llm(
-    model_name: str | None = None,
-    max_tokens: int = 16384,
-) -> ChatOpenAI:
-    """Create a ChatOpenAI instance configured for OpenRouter."""
-    api_key = os.environ.get("OPENROUTER_API_KEY", "")
-    if not api_key:
-        raise RuntimeError(
-            "OPENROUTER_API_KEY not set. Get one at https://openrouter.ai/keys"
-        )
-
-    model = model_name or DEFAULT_MODEL
-    return ChatOpenAI(
-        model=model,
-        openai_api_key=api_key,
-        openai_api_base=OPENROUTER_BASE_URL,
-        max_tokens=max_tokens,
-        default_headers={
-            "HTTP-Referer": "https://github.com/anthropics/flashlight",
-            "X-Title": "flashlight",
-        },
-    )
-
-
-# ---------------------------------------------------------------------------
-# Agent tool configurations
-# ---------------------------------------------------------------------------
-
-AGENT_TOOL_MAP = {
-    "code-library-analyzer": ANALYSIS_TOOLS,
-    "application-analyzer": ANALYSIS_TOOLS,
-    "architecture-documenter": DOCUMENTER_TOOLS,
-    "external-service-analyzer": ANALYSIS_TOOLS,
-}
-
-
-# ---------------------------------------------------------------------------
-# Subagent graph (ReAct loop for individual component analysis)
-# ---------------------------------------------------------------------------
-
-
-def build_subagent_graph(
-    system_prompt: str,
-    tools: list,
-    model_name: str | None = None,
-) -> StateGraph:
-    """Build a tool-calling agent graph for a specialized subagent.
-
-    Creates a ReAct-style loop:
-        agent_node -> should_continue -> tool_node -> agent_node -> ...
-
-    Args:
-        system_prompt: System prompt for this subagent.
-        tools: List of LangChain tool objects available to this agent.
-        model_name: OpenRouter model identifier.
-
-    Returns:
-        Compiled LangGraph StateGraph.
-    """
-    llm = _make_llm(model_name=model_name).bind_tools(tools)
-    tool_node = ToolNode(tools)
-
-    def agent_node(state: SubagentState) -> dict:
-        """Invoke the LLM with the current message history."""
-        messages = state["messages"]
-        if not messages or not isinstance(messages[0], SystemMessage):
-            messages = [SystemMessage(content=system_prompt)] + list(messages)
-
-        response = llm.invoke(messages)
-        return {"messages": [response]}
-
-    def should_continue(state: SubagentState) -> Literal["tools", "__end__"]:
-        """Route based on whether the last message has tool calls."""
-        last_message = state["messages"][-1]
-        if isinstance(last_message, AIMessage) and last_message.tool_calls:
-            return "tools"
-        return "__end__"
-
-    graph = StateGraph(SubagentState)
-    graph.add_node("agent", agent_node)
-    graph.add_node("tools", tool_node)
-    graph.set_entry_point("agent")
-    graph.add_conditional_edges("agent", should_continue)
-    graph.add_edge("tools", "agent")
-
-    return graph.compile()
-
-
-# ---------------------------------------------------------------------------
-# Parallel layer-based orchestration (primary entry point)
-# ---------------------------------------------------------------------------
-
-
-def run_parallel_analysis(
-    components: List[Any],
-    agent_prompts: Dict[str, str],
-    model_name: str | None = None,
-    callback_handler: Optional[FlashlightCallbackHandler] = None,
-    max_workers: int = 10,
-) -> Dict[str, Any]:
-    """Run parallel layer-based analysis of all components.
-
-    This is the primary entry point for analyzing a codebase:
-
-    1. Builds a dependency graph from component.internal_dependencies
-    2. Computes topological layers (leaves first)
-    3. Dispatches all subagents in a layer in parallel
-    4. Waits for layer completion before proceeding
-    5. Passes accumulated analysis context to subsequent layers
-
-    Args:
-        components: List of discovered Component objects.
-        agent_prompts: Map of subagent type -> system prompt.
-        model_name: OpenRouter model identifier.
-        callback_handler: Optional callback handler for observability.
-        max_workers: Maximum parallel subagents per layer.
-
-    Returns:
-        Dict mapping component name to SubagentResult with analysis output.
-
-    Example:
-        from agent.discovery.engine import discover_components
-        from agent.graph import run_parallel_analysis
-
-        components = discover_components(repo_path)
-        results = run_parallel_analysis(
-            components=components,
-            agent_prompts=AGENT_PROMPTS,
-            callback_handler=my_callback,
-        )
-
-        for name, result in results.items():
-            if result.success:
-                print(f"{name}: {result.output[:200]}...")
-    """
-    from agent.orchestrator import ParallelOrchestrator, make_subagent_runner
-
-    runner = make_subagent_runner(
-        build_graph_fn=build_subagent_graph,
-        agent_prompts=agent_prompts,
-        model_name=model_name,
-        callback_handler=callback_handler,
-    )
-
-    orchestrator = ParallelOrchestrator(
-        components=components,
-        subagent_runner=runner,
-        callback_handler=callback_handler,
-        max_workers=max_workers,
-        agent_prompts=agent_prompts,
-    )
-
-    return orchestrator.run()
-
-
-def build_analysis_pipeline(
-    components: List[Any],
-    agent_prompts: Dict[str, str],
-    synthesis_prompt: str,
-    model_name: str | None = None,
-    callback_handler: Optional[FlashlightCallbackHandler] = None,
-    max_workers: int = 10,
-) -> StateGraph:
-    """Build a complete analysis pipeline with parallel dispatch + synthesis.
-
-    Creates a LangGraph that:
-    1. Runs parallel layer-based analysis of all components
-    2. Synthesizes results into final documentation
-
-    Args:
-        components: List of discovered Component objects.
-        agent_prompts: Map of subagent type -> system prompt.
-        synthesis_prompt: System prompt for the synthesis phase.
-        model_name: OpenRouter model identifier.
-        callback_handler: Optional callback handler.
-        max_workers: Maximum parallel subagents per layer.
-
-    Returns:
-        Compiled LangGraph StateGraph.
-    """
-    from typing import TypedDict
-
-    from agent.orchestrator import (
-        ParallelOrchestrator,
-        build_dependency_layers,
-        make_subagent_runner,
-    )
-
-    layers, _ = build_dependency_layers(components)
-    llm = _make_llm(model_name=model_name)
-
-    runner = make_subagent_runner(
-        build_graph_fn=build_subagent_graph,
-        agent_prompts=agent_prompts,
-        model_name=model_name,
-        callback_handler=callback_handler,
-    )
-
-    class PipelineState(TypedDict):
-        """State for the analysis pipeline."""
-
-        messages: List[Any]
-        analysis_results: dict
-        layers_completed: int
-        synthesis_complete: bool
-
-    def parallel_analysis_node(state: PipelineState) -> dict:
-        """Execute parallel layer-based analysis."""
-        orchestrator = ParallelOrchestrator(
-            components=components,
-            subagent_runner=runner,
-            callback_handler=callback_handler,
-            max_workers=max_workers,
-            agent_prompts=agent_prompts,
-        )
-
-        results = orchestrator.run()
-
-        analysis_results = {
-            name: {
-                "success": r.success,
-                "output": r.output,
-                "error": r.error,
-                "duration": r.duration_seconds,
-            }
-            for name, r in results.items()
-        }
-
-        return {
-            "analysis_results": analysis_results,
-            "layers_completed": len(layers),
-        }
-
-    def synthesis_node(state: PipelineState) -> dict:
-        """Synthesize all analysis results into final documentation."""
-        results = state.get("analysis_results", {})
-
-        results_text = "\n\n".join(
-            f"## {name}\n{data.get('output', 'No output')}"
-            for name, data in results.items()
-            if data.get("success", False)
-        )
-
-        synthesis_message = HumanMessage(
-            content=f"""Based on the following component analyses, synthesize a comprehensive 
-architecture document for the codebase.
-
-{results_text}
-
-Please create:
-1. Executive Summary
-2. System Architecture Overview  
-3. Component Relationships
-4. Key Design Patterns
-5. External Dependencies Analysis
-6. Recommendations
-"""
-        )
-
-        messages = [
-            SystemMessage(content=synthesis_prompt),
-            synthesis_message,
-        ]
-
-        response = llm.invoke(messages)
-
-        return {
-            "messages": [synthesis_message, response],
-            "synthesis_complete": True,
-        }
-
-    def should_synthesize(state: PipelineState) -> Literal["synthesis", "__end__"]:
-        """Route to synthesis if analysis is complete."""
-        if state.get("synthesis_complete"):
-            return "__end__"
-        if state.get("analysis_results"):
-            return "synthesis"
-        return "__end__"
-
-    graph = StateGraph(PipelineState)
-    graph.add_node("parallel_analysis", parallel_analysis_node)
-    graph.add_node("synthesis", synthesis_node)
-
-    graph.set_entry_point("parallel_analysis")
-    graph.add_conditional_edges("parallel_analysis", should_synthesize)
-    graph.add_edge("synthesis", "__end__")
-
-    return graph.compile()
-
-
-# ---------------------------------------------------------------------------
-# Lead agent graph (interactive CLI)
-# ---------------------------------------------------------------------------
-
-
-def build_lead_graph(
-    system_prompt: str,
-    agent_prompts: Dict[str, str],
-    model_name: str | None = None,
-    callback_handler: Optional[FlashlightCallbackHandler] = None,
-) -> StateGraph:
-    """Build the interactive lead agent graph for CLI usage.
-
-    Creates a ReAct-style agent loop that:
-        1. Receives user input
-        2. Invokes the LLM with tools
-        3. Executes tool calls
-        4. Continues until LLM produces a final response
-
-    The lead agent can use file exploration tools to understand the codebase
-    and coordinate analysis work.
-
-    Args:
-        system_prompt: System prompt for the lead agent.
-        agent_prompts: Map of subagent type -> system prompt (for future use).
-        model_name: OpenRouter model identifier.
-        callback_handler: Optional callback handler for observability.
-
-    Returns:
-        Compiled LangGraph StateGraph.
-
-    Example:
-        graph = build_lead_graph(
-            system_prompt=load_prompt("lead_agent.txt"),
-            agent_prompts={"code-library-analyzer": "..."},
-        )
-
-        state = {"messages": [], "subagent_results": {}, ...}
-        result = graph.invoke(state, config={"callbacks": [handler]})
-    """
-    llm = _make_llm(model_name=model_name).bind_tools(LEAD_AGENT_TOOLS)
-    tool_node = ToolNode(LEAD_AGENT_TOOLS)
-
-    def agent_node(state: LeadAgentState) -> dict:
-        """Invoke the lead agent LLM with conversation history."""
-        messages = list(state.get("messages", []))
-
-        # Ensure system prompt is first
-        if not messages or not isinstance(messages[0], SystemMessage):
-            messages = [SystemMessage(content=system_prompt)] + messages
-
-        response = llm.invoke(messages)
-        return {"messages": [response]}
-
-    def should_continue(state: LeadAgentState) -> Literal["tools", "__end__"]:
-        """Route based on whether the last message has tool calls."""
-        messages = state.get("messages", [])
-        if not messages:
-            return "__end__"
-
-        last_message = messages[-1]
-        if isinstance(last_message, AIMessage) and last_message.tool_calls:
-            return "tools"
-        return "__end__"
-
-    graph = StateGraph(LeadAgentState)
-    graph.add_node("agent", agent_node)
-    graph.add_node("tools", tool_node)
-
-    graph.set_entry_point("agent")
-    graph.add_conditional_edges("agent", should_continue)
-    graph.add_edge("tools", "agent")
-
-    return graph.compile()
diff --git a/agent/orchestrator_langgraph_legacy.py b/agent/orchestrator_langgraph_legacy.py
deleted file mode 100644
index 7d6aeff..0000000
--- a/agent/orchestrator_langgraph_legacy.py
+++ /dev/null
@@ -1,628 +0,0 @@
-"""Layer-aware parallel orchestration for multi-agent analysis.
-
-This module implements deterministic, layer-based parallel dispatch of subagents
-based on the component dependency graph. Instead of relying on LLM ReAct reasoning
-to decide when to spawn subagents, we:
-
-1. Build a dependency graph from discovered components
-2. Compute topological layers (leaves first, then dependents)
-3. Dispatch all subagents within a layer in parallel
-4. Wait for layer completion before proceeding to the next layer
-5. Pass accumulated context from prior layers to subsequent ones
-
-Architecture:
-                    ┌─────────────────────────────────────┐
-                    │       Component Discovery            │
-                    │   (discover_components from engine)  │
-                    └─────────────────┬───────────────────┘
-                                      │
-                                      ▼
-                    ┌─────────────────────────────────────┐
-                    │      Dependency Graph Builder        │
-                    │   (build_dependency_layers)          │
-                    └─────────────────┬───────────────────┘
-                                      │
-                    ┌─────────────────▼───────────────────┐
-                    │            LAYER 0 (Leaves)          │
-                    │     [parallel: crypto, utils, ...]   │
-                    └─────────────────┬───────────────────┘
-                                      │ await all
-                    ┌─────────────────▼───────────────────┐
-                    │            LAYER 1                   │
-                    │     [parallel: auth, storage, ...]   │
-                    └─────────────────┬───────────────────┘
-                                      │ await all
-                    ┌─────────────────▼───────────────────┐
-                    │            LAYER N (Root)            │
-                    │     [parallel: main-app, ...]        │
-                    └─────────────────┬───────────────────┘
-                                      │
-                                      ▼
-                    ┌─────────────────────────────────────┐
-                    │       Synthesis (Lead Agent)         │
-                    │   Combine all results into docs      │
-                    └─────────────────────────────────────┘
-"""
-
-import logging
-from collections import defaultdict
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple
-
-from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
-
-from agent.callbacks import FlashlightCallbackHandler
-from agent.schemas.core import Component, ComponentKind
-
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Dependency graph and layer computation
-# ---------------------------------------------------------------------------
-
-
-def build_dependency_graph(
-    components: List[Component],
-) -> Dict[str, Set[str]]:
-    """Build adjacency list representation of component dependencies.
-
-    Args:
-        components: List of discovered components with internal_dependencies.
-
-    Returns:
-        Dict mapping component name -> set of component names it depends on.
-    """
-    # Create name -> component mapping
-    by_name = {c.name: c for c in components}
-
-    # Build adjacency list (component -> its dependencies)
-    graph: Dict[str, Set[str]] = {}
-    for comp in components:
-        deps = set()
-        for dep_name in comp.internal_dependencies:
-            if dep_name in by_name:
-                deps.add(dep_name)
-        graph[comp.name] = deps
-
-    return graph
-
-
-def compute_topological_layers(
-    graph: Dict[str, Set[str]],
-) -> List[List[str]]:
-    """Compute topological layers using Kahn's algorithm variant.
-
-    Layer 0 contains nodes with no dependencies (leaves).
-    Layer N contains nodes whose dependencies are all in layers < N.
-
-    Args:
-        graph: Adjacency list (node -> set of dependencies).
-
-    Returns:
-        List of layers, where each layer is a list of component names
-        that can be processed in parallel.
-
-    Raises:
-        ValueError: If the graph contains cycles.
-    """
-    # Compute in-degree (number of dependents) for each node
-    # We want reverse topological order: leaves first
-    # So we track how many deps each node has remaining
-    remaining_deps: Dict[str, int] = {node: len(deps) for node, deps in graph.items()}
-
-    # Reverse graph: for each node, who depends on it?
-    dependents: Dict[str, Set[str]] = defaultdict(set)
-    for node, deps in graph.items():
-        for dep in deps:
-            dependents[dep].add(node)
-
-    layers: List[List[str]] = []
-    processed: Set[str] = set()
-
-    while len(processed) < len(graph):
-        # Find all nodes with no remaining dependencies
-        current_layer = [
-            node
-            for node, deps_left in remaining_deps.items()
-            if deps_left == 0 and node not in processed
-        ]
-
-        if not current_layer:
-            # No progress = cycle detected
-            unprocessed = set(graph.keys()) - processed
-            raise ValueError(f"Dependency cycle detected involving: {unprocessed}")
-
-        layers.append(current_layer)
-
-        # Mark as processed and update remaining deps for dependents
-        for node in current_layer:
-            processed.add(node)
-            for dependent in dependents[node]:
-                remaining_deps[dependent] -= 1
-
-    return layers
-
-
-def build_dependency_layers(
-    components: List[Component],
-) -> Tuple[List[List[Component]], Dict[str, Set[str]]]:
-    """Build dependency layers from components.
-
-    Args:
-        components: List of discovered components.
-
-    Returns:
-        Tuple of (layers, dependency_graph) where layers is a list of
-        component lists that can be processed in parallel.
-    """
-    graph = build_dependency_graph(components)
-    layer_names = compute_topological_layers(graph)
-
-    by_name = {c.name: c for c in components}
-    layers = [
-        [by_name[name] for name in layer if name in by_name] for layer in layer_names
-    ]
-
-    return layers, graph
-
-
-# ---------------------------------------------------------------------------
-# Subagent task and result types
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class SubagentTask:
-    """A task to be executed by a subagent."""
-
-    component: Component
-    subagent_type: str
-    prompt: str
-    layer_index: int
-    prior_context: str = ""  # Accumulated results from prior layers
-
-    @property
-    def task_id(self) -> str:
-        return f"L{self.layer_index}:{self.component.name}"
-
-
-@dataclass
-class SubagentResult:
-    """Result from a subagent execution."""
-
-    task: SubagentTask
-    success: bool
-    output: str
-    error: Optional[str] = None
-    start_time: Optional[datetime] = None
-    end_time: Optional[datetime] = None
-    token_usage: Dict[str, int] = field(default_factory=dict)
-
-    @property
-    def duration_seconds(self) -> float:
-        if self.start_time and self.end_time:
-            return (self.end_time - self.start_time).total_seconds()
-        return 0.0
-
-
-# ---------------------------------------------------------------------------
-# Parallel orchestrator
-# ---------------------------------------------------------------------------
-
-
-class ParallelOrchestrator:
-    """Orchestrates parallel execution of subagents by dependency layer.
-
-    Usage:
-        orchestrator = ParallelOrchestrator(
-            components=discovered_components,
-            subagent_runner=my_subagent_runner_fn,
-            callback_handler=my_callback_handler,
-        )
-
-        results = orchestrator.run()
-    """
-
-    def __init__(
-        self,
-        components: List[Component],
-        subagent_runner: Callable[[SubagentTask], SubagentResult],
-        callback_handler: Optional[FlashlightCallbackHandler] = None,
-        max_workers: int = 10,
-        agent_prompts: Optional[Dict[str, str]] = None,
-    ):
-        """Initialize the orchestrator.
-
-        Args:
-            components: Discovered components to analyze.
-            subagent_runner: Function that executes a single subagent task.
-            callback_handler: Optional callback handler for observability.
-            max_workers: Maximum parallel subagents per layer.
-            agent_prompts: Map of subagent type -> system prompt.
-        """
-        self.components = components
-        self.subagent_runner = subagent_runner
-        self.callback_handler = callback_handler
-        self.max_workers = max_workers
-        self.agent_prompts = agent_prompts or {}
-
-        # Build dependency layers
-        self.layers, self.dep_graph = build_dependency_layers(components)
-
-        # Track results by component name
-        self.results: Dict[str, SubagentResult] = {}
-
-    def _determine_subagent_type(self, component: Component) -> str:
-        """Determine which subagent type should analyze this component."""
-        if component.kind == ComponentKind.LIBRARY:
-            return "code-library-analyzer"
-        elif component.kind in (
-            ComponentKind.SERVICE,
-            ComponentKind.CLI,
-            ComponentKind.FRONTEND,
-        ):
-            return "application-analyzer"
-        elif component.kind == ComponentKind.CONTRACT:
-            return "code-library-analyzer"  # Contracts are analyzed like libraries
-        elif component.kind == ComponentKind.INFRA:
-            return "external-service-analyzer"
-        else:
-            return "code-library-analyzer"  # Default
-
-    def _build_prompt(
-        self,
-        component: Component,
-        prior_context: str,
-    ) -> str:
-        """Build the prompt for analyzing a component."""
-        deps_info = ""
-        if component.internal_dependencies:
-            deps_info = f"\n\nThis component depends on: {', '.join(component.internal_dependencies)}"
-            # Include analysis results of dependencies
-            dep_analyses = []
-            for dep_name in component.internal_dependencies:
-                if dep_name in self.results:
-                    dep_result = self.results[dep_name]
-                    if dep_result.success:
-                        dep_analyses.append(
-                            f"### {dep_name}\n{dep_result.output[:2000]}..."
-                            if len(dep_result.output) > 2000
-                            else f"### {dep_name}\n{dep_result.output}"
-                        )
-            if dep_analyses:
-                deps_info += "\n\n## Prior Analysis of Dependencies:\n" + "\n\n".join(
-                    dep_analyses
-                )
-
-        return f"""Analyze the following component:
-
-**Name:** {component.name}
-**Type:** {component.type}
-**Kind:** {component.kind.value}
-**Root Path:** {component.root_path}
-**Description:** {component.description or "No description available"}
-{deps_info}
-
-Please provide a comprehensive analysis including:
-1. Main purpose and responsibilities
-2. Key interfaces and APIs
-3. Internal architecture patterns
-4. Dependencies and how they're used
-5. Notable implementation details
-
-{prior_context}
-"""
-
-    def _create_tasks_for_layer(
-        self,
-        layer_index: int,
-        layer_components: List[Component],
-    ) -> List[SubagentTask]:
-        """Create subagent tasks for a layer of components."""
-        # Build accumulated context from all prior layers
-        prior_context = ""
-        if layer_index > 0:
-            completed_summaries = []
-            for name, result in self.results.items():
-                if result.success:
-                    # Include brief summary
-                    summary = (
-                        result.output[:500] + "..."
-                        if len(result.output) > 500
-                        else result.output
-                    )
-                    completed_summaries.append(f"- **{name}**: {summary}")
-            if completed_summaries:
-                prior_context = "## Previously Analyzed Components:\n" + "\n".join(
-                    completed_summaries
-                )
-
-        tasks = []
-        for comp in layer_components:
-            subagent_type = self._determine_subagent_type(comp)
-            prompt = self._build_prompt(comp, prior_context)
-
-            task = SubagentTask(
-                component=comp,
-                subagent_type=subagent_type,
-                prompt=prompt,
-                layer_index=layer_index,
-                prior_context=prior_context,
-            )
-            tasks.append(task)
-
-        return tasks
-
-    def _log_layer_start(self, layer_index: int, tasks: List[SubagentTask]) -> None:
-        """Log the start of a layer execution."""
-        if self.callback_handler:
-            self.callback_handler._log_to_jsonl(
-                {
-                    "event": "layer_start",
-                    "timestamp": datetime.now().isoformat(),
-                    "layer_index": layer_index,
-                    "total_layers": len(self.layers),
-                    "component_count": len(tasks),
-                    "components": [t.component.name for t in tasks],
-                }
-            )
-
-        logger.info(
-            "=" * 60 + "\n"
-            f"LAYER {layer_index}/{len(self.layers) - 1}: "
-            f"Dispatching {len(tasks)} subagents in parallel\n"
-            f"Components: {[t.component.name for t in tasks]}\n" + "=" * 60
-        )
-
-    def _log_layer_complete(
-        self,
-        layer_index: int,
-        results: List[SubagentResult],
-        duration: float,
-    ) -> None:
-        """Log the completion of a layer."""
-        successful = sum(1 for r in results if r.success)
-        failed = len(results) - successful
-
-        if self.callback_handler:
-            self.callback_handler._log_to_jsonl(
-                {
-                    "event": "layer_complete",
-                    "timestamp": datetime.now().isoformat(),
-                    "layer_index": layer_index,
-                    "successful": successful,
-                    "failed": failed,
-                    "duration_seconds": duration,
-                    "results": [
-                        {
-                            "component": r.task.component.name,
-                            "success": r.success,
-                            "duration": r.duration_seconds,
-                            "error": r.error,
-                        }
-                        for r in results
-                    ],
-                }
-            )
-
-        logger.info(
-            f"LAYER {layer_index} COMPLETE: "
-            f"{successful} succeeded, {failed} failed "
-            f"({duration:.1f}s total)"
-        )
-
-    def run(self) -> Dict[str, SubagentResult]:
-        """Execute all subagents layer by layer with parallel dispatch.
-
-        Returns:
-            Dict mapping component name to its SubagentResult.
-        """
-        total_start = datetime.now()
-
-        logger.info(
-            f"Starting parallel orchestration: "
-            f"{len(self.components)} components in {len(self.layers)} layers"
-        )
-
-        if self.callback_handler:
-            self.callback_handler._log_to_jsonl(
-                {
-                    "event": "orchestration_start",
-                    "timestamp": total_start.isoformat(),
-                    "total_components": len(self.components),
-                    "total_layers": len(self.layers),
-                    "layer_sizes": [len(layer) for layer in self.layers],
-                }
-            )
-
-        for layer_index, layer_components in enumerate(self.layers):
-            if not layer_components:
-                continue
-
-            # Create tasks for this layer
-            tasks = self._create_tasks_for_layer(layer_index, layer_components)
-            self._log_layer_start(layer_index, tasks)
-
-            layer_start = datetime.now()
-            layer_results: List[SubagentResult] = []
-
-            # Execute all tasks in parallel
-            with ThreadPoolExecutor(
-                max_workers=min(self.max_workers, len(tasks))
-            ) as executor:
-                # Submit all tasks
-                future_to_task = {
-                    executor.submit(self._run_single_task, task): task for task in tasks
-                }
-
-                # Collect results as they complete
-                for future in as_completed(future_to_task):
-                    task = future_to_task[future]
-                    try:
-                        result = future.result()
-                    except Exception as exc:
-                        logger.error(f"Task {task.task_id} raised exception: {exc}")
-                        result = SubagentResult(
-                            task=task,
-                            success=False,
-                            output="",
-                            error=str(exc),
-                            start_time=datetime.now(),
-                            end_time=datetime.now(),
-                        )
-
-                    layer_results.append(result)
-                    self.results[task.component.name] = result
-
-            layer_duration = (datetime.now() - layer_start).total_seconds()
-            self._log_layer_complete(layer_index, layer_results, layer_duration)
-
-        total_duration = (datetime.now() - total_start).total_seconds()
-
-        if self.callback_handler:
-            successful = sum(1 for r in self.results.values() if r.success)
-            self.callback_handler._log_to_jsonl(
-                {
-                    "event": "orchestration_complete",
-                    "timestamp": datetime.now().isoformat(),
-                    "total_duration_seconds": total_duration,
-                    "successful": successful,
-                    "failed": len(self.results) - successful,
-                }
-            )
-
-        logger.info(
-            f"Orchestration complete: {len(self.results)} components analyzed "
-            f"in {total_duration:.1f}s"
-        )
-
-        return self.results
-
-    def _run_single_task(self, task: SubagentTask) -> SubagentResult:
-        """Execute a single subagent task with callback tracking."""
-        start_time = datetime.now()
-
-        # Set subagent context for callbacks
-        if self.callback_handler:
-            self.callback_handler.set_subagent_context(
-                task.subagent_type,
-                f"L{task.layer_index}:{task.component.name}",
-            )
-
-        try:
-            result = self.subagent_runner(task)
-            result.start_time = start_time
-            result.end_time = datetime.now()
-            return result
-        except Exception as exc:
-            return SubagentResult(
-                task=task,
-                success=False,
-                output="",
-                error=str(exc),
-                start_time=start_time,
-                end_time=datetime.now(),
-            )
-        finally:
-            if self.callback_handler:
-                self.callback_handler.clear_subagent_context()
-
-
-# ---------------------------------------------------------------------------
-# Helper to create a subagent runner from a LangGraph
-# ---------------------------------------------------------------------------
-
-
-def make_subagent_runner(
-    build_graph_fn: Callable,
-    agent_prompts: Dict[str, str],
-    model_name: Optional[str] = None,
-    callback_handler: Optional[FlashlightCallbackHandler] = None,
-) -> Callable[[SubagentTask], SubagentResult]:
-    """Create a subagent runner function from a graph builder.
-
-    Args:
-        build_graph_fn: Function that builds a subagent graph.
-        agent_prompts: Map of subagent type -> system prompt.
-        model_name: Model to use for subagents.
-        callback_handler: Optional callback handler.
-
-    Returns:
-        A function that takes a SubagentTask and returns a SubagentResult.
-    """
-
-    def runner(task: SubagentTask) -> SubagentResult:
-        from agent.tools import ANALYSIS_TOOLS, DOCUMENTER_TOOLS
-
-        # Get system prompt and tools for this subagent type
-        system_prompt = agent_prompts.get(task.subagent_type, "")
-        if not system_prompt:
-            return SubagentResult(
-                task=task,
-                success=False,
-                output="",
-                error=f"Unknown subagent type: {task.subagent_type}",
-            )
-
-        tools = ANALYSIS_TOOLS
-        if task.subagent_type == "architecture-documenter":
-            tools = DOCUMENTER_TOOLS
-
-        # Build and run the graph
-        graph = build_graph_fn(
-            system_prompt=system_prompt,
-            tools=tools,
-            model_name=model_name,
-        )
-
-        config = {}
-        if callback_handler:
-            config["callbacks"] = [callback_handler]
-
-        try:
-            result = graph.invoke(
-                {
-                    "messages": [HumanMessage(content=task.prompt)],
-                    "subagent_type": task.subagent_type,
-                    "description": task.component.name,
-                    "service_name": "",
-                    "repo_path": task.component.root_path,
-                },
-                config=config,
-            )
-
-            # Extract final output
-            final_messages = result.get("messages", [])
-            output = ""
-            for msg in reversed(final_messages):
-                if isinstance(msg, AIMessage) and msg.content:
-                    if isinstance(msg.content, str):
-                        output = msg.content
-                    elif isinstance(msg.content, list):
-                        text_parts = [
-                            block.get("text", "")
-                            for block in msg.content
-                            if isinstance(block, dict) and block.get("type") == "text"
-                        ]
-                        output = "\n".join(text_parts)
-                    break
-
-            return SubagentResult(
-                task=task,
-                success=True,
-                output=output or "Analysis completed (no text output)",
-            )
-
-        except Exception as exc:
-            logger.error(f"Subagent {task.task_id} failed: {exc}", exc_info=True)
-            return SubagentResult(
-                task=task,
-                success=False,
-                output="",
-                error=str(exc),
-            )
-
-    return runner
diff --git a/agent/state.py b/agent/state.py
deleted file mode 100644
index a5a0e2e..0000000
--- a/agent/state.py
+++ /dev/null
@@ -1,103 +0,0 @@
-"""LangGraph state definitions for the flashlight multi-agent system.
-
-Defines the shared state schemas used by the lead agent graph and
-subagent subgraphs. Uses TypedDict with LangGraph's Annotated reducers
-for message accumulation.
-"""
-
-import os
-from dataclasses import dataclass, field
-from typing import Annotated, Any, Dict, List, Optional, Sequence
-
-from langchain_core.messages import BaseMessage
-from langgraph.graph.message import add_messages
-
-# Default model from environment variable
-DEFAULT_MODEL = os.environ.get("OPENROUTER_MODEL", "anthropic/claude-sonnet-4")
-
-
-# ---------------------------------------------------------------------------
-# Lead agent state
-# ---------------------------------------------------------------------------
-
-
-class AgentState(dict):
-    """State for the lead orchestrator agent.
-
-    Attributes:
-        messages: Accumulated conversation messages (LLM + tool results).
-        subagent_results: Map of subagent task descriptions to their outputs.
-        pending_subagents: List of subagent tasks queued for execution.
-        completed_subagents: Count of completed subagent tasks.
-        service_name: Name of the service being analyzed.
-        repo_path: Path to the cloned repository.
-    """
-
-    messages: Annotated[Sequence[BaseMessage], add_messages]
-    subagent_results: Dict[str, str]
-    pending_subagents: List[Dict[str, Any]]
-    completed_subagents: int
-    service_name: str
-    repo_path: str
-
-
-# Using TypedDict for LangGraph compatibility
-from typing import TypedDict
-
-
-class LeadAgentState(TypedDict):
-    """State schema for the lead orchestrator graph."""
-
-    messages: Annotated[list[BaseMessage], add_messages]
-    subagent_results: dict[str, str]
-    service_name: str
-    repo_path: str
-
-
-class SubagentState(TypedDict):
-    """State schema for individual subagent (code analyzer, etc.) graphs."""
-
-    messages: Annotated[list[BaseMessage], add_messages]
-    subagent_type: str
-    description: str
-    service_name: str
-    repo_path: str
-
-
-# ---------------------------------------------------------------------------
-# Subagent task descriptor
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class SubagentTask:
-    """Describes a subagent to be spawned by the lead agent.
-
-    Created when the lead agent decides to delegate analysis of a component
-    to a specialized subagent.
-    """
-
-    subagent_type: str  # e.g., "code-library-analyzer", "application-analyzer"
-    description: str  # e.g., "Analyze the crypto library"
-    prompt: str  # Full prompt to send to the subagent
-    tools: List[str] = field(default_factory=list)  # Tool names this agent needs
-    model: str = field(default_factory=lambda: DEFAULT_MODEL)
-
-    def to_dict(self) -> dict:
-        return {
-            "subagent_type": self.subagent_type,
-            "description": self.description,
-            "prompt": self.prompt,
-            "tools": self.tools,
-            "model": self.model,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "SubagentTask":
-        return cls(
-            subagent_type=data["subagent_type"],
-            description=data["description"],
-            prompt=data["prompt"],
-            tools=data.get("tools", []),
-            model=data.get("model", DEFAULT_MODEL),
-        )
diff --git a/agent/tools.py b/agent/tools.py
deleted file mode 100644
index e609f2f..0000000
--- a/agent/tools.py
+++ /dev/null
@@ -1,275 +0,0 @@
-"""LangGraph-compatible tool implementations.
-
-Replaces the built-in tools previously provided by claude-agent-sdk
-(Glob, Grep, Read, Bash, Write) with explicit Python implementations
-decorated as LangChain tools.
-"""
-
-import fnmatch
-import os
-import re
-import subprocess
-from pathlib import Path
-from typing import Optional
-
-from langchain_core.tools import tool
-
-
-# ---------------------------------------------------------------------------
-# Read
-# ---------------------------------------------------------------------------
-
-
-@tool
-def read_file(file_path: str, offset: int = 1, limit: int = 2000) -> str:
-    """Read a file from the local filesystem.
-
-    Returns the file contents with each line prefixed by its line number.
-    Use offset and limit to read specific sections of large files.
-
-    Args:
-        file_path: Absolute path to the file to read.
-        offset: Line number to start reading from (1-indexed, default 1).
-        limit: Maximum number of lines to return (default 2000).
-    """
-    p = Path(file_path)
-    if not p.exists():
-        return f"Error: path does not exist: {file_path}"
-
-    if p.is_dir():
-        entries = sorted(p.iterdir())
-        lines = []
-        for entry in entries:
-            name = entry.name + ("/" if entry.is_dir() else "")
-            lines.append(name)
-        return "\n".join(lines) if lines else "(empty directory)"
-
-    try:
-        text = p.read_text(encoding="utf-8", errors="replace")
-    except Exception as exc:
-        return f"Error reading {file_path}: {exc}"
-
-    all_lines = text.splitlines(keepends=True)
-    total = len(all_lines)
-
-    # Apply offset (1-indexed) and limit
-    start = max(0, offset - 1)
-    end = start + limit
-    selected = all_lines[start:end]
-
-    result_lines = []
-    for i, line in enumerate(selected, start=start + 1):
-        # Truncate very long lines
-        content = line.rstrip("\n\r")
-        if len(content) > 2000:
-            content = content[:2000] + "... (truncated)"
-        result_lines.append(f"{i}: {content}")
-
-    result = "\n".join(result_lines)
-    if end < total:
-        result += f"\n\n(Showing lines {offset}-{end} of {total} total lines)"
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Write
-# ---------------------------------------------------------------------------
-
-
-@tool
-def write_file(file_path: str, content: str) -> str:
-    """Write content to a file, creating parent directories as needed.
-
-    This will overwrite the file if it already exists.
-
-    Args:
-        file_path: Absolute path to the file to write.
-        content: The content to write to the file.
-    """
-    p = Path(file_path)
-    try:
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(content, encoding="utf-8")
-        return f"Successfully wrote {len(content)} characters to {file_path}"
-    except Exception as exc:
-        return f"Error writing {file_path}: {exc}"
-
-
-# ---------------------------------------------------------------------------
-# Glob
-# ---------------------------------------------------------------------------
-
-
-@tool
-def glob_files(pattern: str, path: Optional[str] = None) -> str:
-    """Find files matching a glob pattern.
-
-    Supports patterns like '**/*.py', 'src/**/*.ts', etc.
-
-    Args:
-        pattern: The glob pattern to match files against.
-        path: The directory to search in. Defaults to current working directory.
-    """
-    base = Path(path) if path else Path.cwd()
-    if not base.exists():
-        return f"Error: directory does not exist: {base}"
-
-    try:
-        matches = sorted(base.glob(pattern))
-        # Filter out directories, only return files
-        files = [str(m) for m in matches if m.is_file()]
-        if not files:
-            return f"No files found matching pattern '{pattern}' in {base}"
-        # Cap output to avoid massive returns
-        if len(files) > 500:
-            result = "\n".join(files[:500])
-            result += f"\n\n... and {len(files) - 500} more files (truncated)"
-            return result
-        return "\n".join(files)
-    except Exception as exc:
-        return f"Error searching for pattern '{pattern}': {exc}"
-
-
-# ---------------------------------------------------------------------------
-# Grep
-# ---------------------------------------------------------------------------
-
-
-@tool
-def grep_files(
-    pattern: str,
-    path: Optional[str] = None,
-    include: Optional[str] = None,
-) -> str:
-    """Search file contents using a regular expression.
-
-    Returns matching file paths and line numbers.
-
-    Args:
-        pattern: The regex pattern to search for in file contents.
-        path: The directory to search in. Defaults to current working directory.
-        include: Optional file pattern to filter by (e.g., '*.py', '*.{ts,tsx}').
-    """
-    base = Path(path) if path else Path.cwd()
-    if not base.exists():
-        return f"Error: directory does not exist: {base}"
-
-    # Build ripgrep command for efficiency; fall back to Python if rg not available
-    cmd = ["rg", "--line-number", "--no-heading", "--color=never"]
-    if include:
-        cmd.extend(["--glob", include])
-    cmd.append(pattern)
-    cmd.append(str(base))
-
-    try:
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
-        output = result.stdout.strip()
-        if not output:
-            return f"No matches found for pattern '{pattern}' in {base}"
-        # Truncate if very large
-        lines = output.split("\n")
-        if len(lines) > 500:
-            output = "\n".join(lines[:500])
-            output += f"\n\n... and {len(lines) - 500} more matches (truncated)"
-        return output
-    except FileNotFoundError:
-        # ripgrep not available, fall back to Python regex search
-        return _grep_python_fallback(pattern, base, include)
-    except subprocess.TimeoutExpired:
-        return f"Error: search timed out after 30 seconds"
-    except Exception as exc:
-        return f"Error searching: {exc}"
-
-
-def _grep_python_fallback(pattern: str, base: Path, include: Optional[str]) -> str:
-    """Pure-Python fallback for grep when ripgrep is not available."""
-    try:
-        regex = re.compile(pattern)
-    except re.error as exc:
-        return f"Invalid regex pattern '{pattern}': {exc}"
-
-    matches = []
-    for root, _dirs, files in os.walk(base):
-        for fname in files:
-            if include:
-                # Simple glob match on filename
-                if not fnmatch.fnmatch(fname, include):
-                    continue
-            fpath = Path(root) / fname
-            try:
-                text = fpath.read_text(encoding="utf-8", errors="ignore")
-                for i, line in enumerate(text.splitlines(), 1):
-                    if regex.search(line):
-                        matches.append(f"{fpath}:{i}:{line}")
-                        if len(matches) >= 500:
-                            matches.append("\n... (truncated at 500 matches)")
-                            return "\n".join(matches)
-            except (OSError, UnicodeDecodeError):
-                continue
-
-    if not matches:
-        return f"No matches found for pattern '{pattern}' in {base}"
-    return "\n".join(matches)
-
-
-# ---------------------------------------------------------------------------
-# Bash
-# ---------------------------------------------------------------------------
-
-
-@tool
-def bash(command: str, workdir: Optional[str] = None, timeout: int = 120) -> str:
-    """Execute a bash command and return its output.
-
-    Args:
-        command: The command to execute.
-        workdir: Optional working directory. Defaults to current directory.
-        timeout: Timeout in seconds (default 120).
-    """
-    cwd = workdir if workdir else None
-    try:
-        result = subprocess.run(
-            command,
-            shell=True,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-            cwd=cwd,
-        )
-        output = ""
-        if result.stdout:
-            output += result.stdout
-        if result.stderr:
-            if output:
-                output += "\n"
-            output += f"STDERR:\n{result.stderr}"
-        if result.returncode != 0:
-            output += f"\n(exit code: {result.returncode})"
-
-        # Truncate very large outputs
-        if len(output) > 100_000:
-            output = output[:100_000] + "\n... (output truncated at 100KB)"
-        return output if output else "(no output)"
-    except subprocess.TimeoutExpired:
-        return f"Error: command timed out after {timeout} seconds"
-    except Exception as exc:
-        return f"Error executing command: {exc}"
-
-
-# ---------------------------------------------------------------------------
-# Tool collections
-# ---------------------------------------------------------------------------
-
-# All tools available for code analysis subagents
-ANALYSIS_TOOLS = [read_file, write_file, glob_files, grep_files, bash]
-
-# Restricted set for architecture documenter (no bash/grep needed)
-DOCUMENTER_TOOLS = [read_file, write_file, glob_files]
-
-# Full set for lead agent (same as analysis tools)
-LEAD_AGENT_TOOLS = [read_file, write_file, glob_files, grep_files, bash]
diff --git a/observability/live_monitor.sh b/observability/live_monitor.sh
deleted file mode 100755
index 81cf27f..0000000
--- a/observability/live_monitor.sh
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/bin/bash
-# LangGraph Session Profiler - Live Monitor
-#
-# Starts the log server and opens the profiler dashboard.
-# The dashboard will auto-connect to the running agent session.
-
-set -e
-
-PORT=${1:-8888}
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
-
-echo ""
-echo "Starting LangGraph Session Profiler..."
-echo ""
-
-# Kill any existing server on this port
-lsof -ti:$PORT 2>/dev/null | xargs kill 2>/dev/null || true
-sleep 1
-
-# Start the server
-cd "$PROJECT_DIR"
-python3 "$SCRIPT_DIR/serve_logs.py" "$PORT" &
-SERVER_PID=$!
-
-# Wait for server to start
-sleep 2
-
-# Check if server is running
-if ! kill -0 $SERVER_PID 2>/dev/null; then
-    echo "Error: Server failed to start"
-    exit 1
-fi
-
-# Open the profiler in browser
-PROFILER_PATH="$SCRIPT_DIR/session_profiler.html"
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    open "$PROFILER_PATH"
-elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
-    xdg-open "$PROFILER_PATH" 2>/dev/null || sensible-browser "$PROFILER_PATH" 2>/dev/null
-else
-    echo "Please open: $PROFILER_PATH"
-fi
-
-# Cleanup on exit
-cleanup() {
-    echo ""
-    echo "Stopping server..."
-    kill $SERVER_PID 2>/dev/null
-    exit 0
-}
-
-trap cleanup INT TERM
-
-# Wait for server
-wait $SERVER_PID
diff --git a/observability/serve_logs.py b/observability/serve_logs.py
deleted file mode 100755
index 0735847..0000000
--- a/observability/serve_logs.py
+++ /dev/null
@@ -1,173 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple HTTP server for LangGraph session profiler.
-
-Serves the tool_calls.jsonl log file for real-time visualization.
-Auto-discovers the latest log file from the project's logs directory.
-
-Usage:
-    python serve_logs.py [port]
-
-Examples:
-    python serve_logs.py                    # Serve on port 8000
-    python serve_logs.py 8080               # Serve on port 8080
-"""
-
-import http.server
-import socketserver
-import sys
-import os
-import json
-from pathlib import Path
-
-
-def find_latest_tool_calls_file():
-    """Find the latest tool_calls.jsonl file in the project logs."""
-    # Check common locations
-    search_paths = [
-        Path(__file__).parent.parent / "logs" / "latest" / "tool_calls.jsonl",
-        Path.cwd() / "logs" / "latest" / "tool_calls.jsonl",
-        Path.cwd().parent / "logs" / "latest" / "tool_calls.jsonl",
-    ]
-    
-    for path in search_paths:
-        if path.exists():
-            return path
-    
-    # Search recursively in logs directory
-    logs_dir = Path(__file__).parent.parent / "logs"
-    if logs_dir.exists():
-        tool_call_files = list(logs_dir.rglob("tool_calls.jsonl"))
-        if tool_call_files:
-            # Return the most recently modified
-            return max(tool_call_files, key=lambda p: p.stat().st_mtime)
-    
-    return None
-
-
-class CORSRequestHandler(http.server.SimpleHTTPRequestHandler):
-    """HTTP request handler with CORS enabled and auto-discovery."""
-
-    # Store paths as class variables
-    tool_calls_file = None
-    base_dir = None
-
-    def do_GET(self):
-        """Handle GET requests with custom endpoints."""
-        # API endpoint: get tool calls file path
-        if self.path == '/get/tool_calls_file':
-            self.send_response(200)
-            self.send_header('Content-Type', 'application/json')
-            self.end_headers()
-
-            # Auto-discover if not set
-            if not self.tool_calls_file:
-                found = find_latest_tool_calls_file()
-                if found:
-                    # Make path relative to base_dir for serving
-                    try:
-                        self.tool_calls_file = str(found.relative_to(self.base_dir))
-                    except ValueError:
-                        self.tool_calls_file = str(found)
-
-            response = {'tool_calls_file': self.tool_calls_file}
-            self.wfile.write(json.dumps(response).encode('utf-8'))
-            return
-
-        # Legacy endpoint for backward compatibility
-        if self.path == '/get/session_id':
-            self.send_response(200)
-            self.send_header('Content-Type', 'application/json')
-            self.end_headers()
-            response = {'session_file': None}  # Deprecated
-            self.wfile.write(json.dumps(response).encode('utf-8'))
-            return
-
-        # Serve files normally
-        return super().do_GET()
-
-    def end_headers(self):
-        # Enable CORS for all origins
-        self.send_header('Access-Control-Allow-Origin', '*')
-        self.send_header('Access-Control-Allow-Methods', 'GET, OPTIONS')
-        self.send_header('Access-Control-Allow-Headers', '*')
-        # Disable caching so browser always gets latest file
-        self.send_header('Cache-Control', 'no-store, no-cache, must-revalidate')
-        self.send_header('Expires', '0')
-        super().end_headers()
-
-    def do_OPTIONS(self):
-        """Handle preflight CORS requests."""
-        self.send_response(200)
-        self.end_headers()
-
-    def log_message(self, format, *args):
-        """Log requests with timestamp."""
-        timestamp = self.log_date_time_string()
-        message = format % args
-        # Only log actual requests, not noise
-        if 'GET' in message and '/get/' not in message:
-            sys.stderr.write(f"  {timestamp} - {message}\n")
-
-
-def main():
-    # Parse command line arguments
-    port = 8000
-    if len(sys.argv) > 1:
-        try:
-            port = int(sys.argv[1])
-        except ValueError:
-            print(f"Invalid port: {sys.argv[1]}")
-            sys.exit(1)
-
-    # Determine base directory (project root)
-    script_dir = Path(__file__).parent
-    project_dir = script_dir.parent
-    
-    # Change to project directory for serving
-    os.chdir(project_dir)
-    CORSRequestHandler.base_dir = project_dir
-
-    # Check for tool calls file from environment or auto-discover
-    tool_calls_file = os.environ.get('FLASHLIGHT_TOOL_CALLS_FILE')
-    if not tool_calls_file:
-        found = find_latest_tool_calls_file()
-        if found:
-            try:
-                tool_calls_file = str(found.relative_to(project_dir))
-            except ValueError:
-                tool_calls_file = str(found)
-
-    CORSRequestHandler.tool_calls_file = tool_calls_file
-
-    # Create server
-    socketserver.TCPServer.allow_reuse_address = True
-    with socketserver.TCPServer(("", port), CORSRequestHandler) as httpd:
-        print()
-        print("╔════════════════════════════════════════════════════════════╗")
-        print("║         LangGraph Session Profiler - Log Server            ║")
-        print("╠════════════════════════════════════════════════════════════╣")
-        print(f"║  Server:  http://localhost:{port:<32}║")
-        
-        if tool_calls_file:
-            # Truncate long paths
-            display_path = tool_calls_file if len(tool_calls_file) < 45 else "..." + tool_calls_file[-42:]
-            print(f"║  Logs:    {display_path:<49}║")
-        else:
-            print("║  Logs:    (auto-discover on request)                       ║")
-        
-        print("╠════════════════════════════════════════════════════════════╣")
-        print("║  Open session_profiler.html and click 'Connect to Agent'   ║")
-        print("║  Press Ctrl+C to stop                                       ║")
-        print("╚════════════════════════════════════════════════════════════╝")
-        print()
-
-        try:
-            httpd.serve_forever()
-        except KeyboardInterrupt:
-            print("\nServer stopped.")
-            sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/observability/session_profiler.html b/observability/session_profiler.html
deleted file mode 100644
index f395395..0000000
--- a/observability/session_profiler.html
+++ /dev/null
@@ -1,4557 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>LangGraph Multi-Agent Session Profiler</title>
-    <script src="https://d3js.org/d3.v7.min.js"></script>
-    <style>
-        * {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
-
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
-            background: #f5f5f5;
-            padding: 20px;
-        }
-
-        .container {
-            max-width: 1600px;
-            margin: 0 auto;
-            background: white;
-            border-radius: 8px;
-            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-            padding: 20px;
-        }
-
-        h1 {
-            color: #333;
-            margin-bottom: 10px;
-            font-size: 28px;
-        }
-
-        .header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 20px;
-            padding-bottom: 20px;
-            border-bottom: 2px solid #e0e0e0;
-        }
-
-        .file-input {
-            display: flex;
-            align-items: center;
-            gap: 10px;
-        }
-
-        .file-input input[type="file"] {
-            padding: 8px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-        }
-
-        .stats {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-            gap: 15px;
-            margin-bottom: 20px;
-        }
-
-        .stat-card {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            padding: 15px;
-            border-radius: 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-
-        .stat-card.warning {
-            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
-        }
-
-        .stat-card.success {
-            background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
-        }
-
-        .stat-label {
-            font-size: 12px;
-            opacity: 0.9;
-            margin-bottom: 5px;
-        }
-
-        .stat-value {
-            font-size: 24px;
-            font-weight: bold;
-        }
-
-        .tabs {
-            display: flex;
-            gap: 10px;
-            margin-bottom: 20px;
-            border-bottom: 2px solid #e0e0e0;
-        }
-
-        .tab {
-            padding: 10px 20px;
-            background: none;
-            border: none;
-            border-bottom: 3px solid transparent;
-            cursor: pointer;
-            font-size: 16px;
-            color: #666;
-            transition: all 0.3s;
-        }
-
-        .tab:hover {
-            color: #333;
-        }
-
-        .tab.active {
-            color: #667eea;
-            border-bottom-color: #667eea;
-        }
-
-        .tab-content {
-            display: none;
-        }
-
-        .tab-content.active {
-            display: block;
-        }
-
-        .visualization {
-            background: white;
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-        }
-
-        .timeline-container {
-            position: relative;
-        }
-
-        .agent-timeline {
-            margin-bottom: 30px;
-            position: relative;
-        }
-
-        .agent-label {
-            font-weight: bold;
-            font-size: 14px;
-            margin-bottom: 10px;
-            color: #333;
-            display: flex;
-            align-items: center;
-            gap: 10px;
-        }
-
-        .agent-badge {
-            background: #667eea;
-            color: white;
-            padding: 2px 8px;
-            border-radius: 12px;
-            font-size: 11px;
-        }
-
-        .timeline-axis {
-            position: relative;
-            height: 60px;
-            margin: 10px 0;
-        }
-
-        .tool-call-point {
-            cursor: pointer;
-            transition: all 0.2s;
-        }
-
-        .tool-call-point:hover {
-            opacity: 1 !important;
-            transform: scale(1.2);
-        }
-
-        .tooltip {
-            position: absolute;
-            background: rgba(0, 0, 0, 0.9);
-            color: white;
-            padding: 12px;
-            border-radius: 6px;
-            font-size: 12px;
-            pointer-events: none;
-            z-index: 1000;
-            max-width: 300px;
-            box-shadow: 0 4px 12px rgba(0,0,0,0.3);
-        }
-
-        .tooltip-title {
-            font-weight: bold;
-            margin-bottom: 8px;
-            font-size: 14px;
-            border-bottom: 1px solid rgba(255,255,255,0.3);
-            padding-bottom: 5px;
-        }
-
-        .tooltip-row {
-            display: flex;
-            justify-content: space-between;
-            margin: 4px 0;
-        }
-
-        .tooltip-label {
-            opacity: 0.8;
-        }
-
-        .legend {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 15px;
-            margin-top: 20px;
-            padding: 15px;
-            background: #f9f9f9;
-            border-radius: 6px;
-        }
-
-        .legend-item {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-            font-size: 13px;
-        }
-
-        .legend-color {
-            width: 20px;
-            height: 20px;
-            border-radius: 50%;
-            border: 2px solid #333;
-        }
-
-        .filter-controls {
-            display: flex;
-            gap: 15px;
-            margin-bottom: 20px;
-            padding: 15px;
-            background: #f9f9f9;
-            border-radius: 6px;
-            flex-wrap: wrap;
-        }
-
-        .filter-group {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-        }
-
-        .filter-group label {
-            font-size: 14px;
-            font-weight: 500;
-        }
-
-        .filter-group select {
-            padding: 6px 12px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            background: white;
-        }
-
-        #lifespanChart {
-            margin-top: 20px;
-        }
-
-        .loading {
-            text-align: center;
-            padding: 40px;
-            color: #666;
-        }
-
-        .error {
-            background: #fee;
-            color: #c33;
-            padding: 15px;
-            border-radius: 6px;
-            margin: 20px 0;
-        }
-
-        .weight-badge {
-            padding: 2px 6px;
-            border-radius: 3px;
-            font-size: 11px;
-            font-weight: bold;
-        }
-
-        .weight-negligible { background: #90EE90; color: #333; }
-        .weight-moderate { background: #FFD700; color: #333; }
-        .weight-heavy { background: #FFA500; color: white; }
-        .weight-critical { background: #FF4500; color: white; }
-
-        #clusterGraph {
-            border: 1px solid #ddd;
-            border-radius: 6px;
-            background: #fafafa;
-        }
-
-        .cluster-node {
-            cursor: pointer;
-            transition: all 0.2s;
-        }
-
-        .cluster-node:hover {
-            stroke-width: 3px !important;
-        }
-
-        .cluster-link {
-            stroke: #999;
-            stroke-opacity: 0.3;
-        }
-
-        .cluster-legend {
-            background: white;
-            padding: 15px;
-            border-radius: 6px;
-            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-            margin-top: 15px;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <div>
-                <h1>LangGraph Session Profiler</h1>
-                <p style="color: #666; margin-top: 5px;">Interactive analysis of LangGraph agent tool usage, node transitions, and resource weights</p>
-            </div>
-            <div class="file-input" style="display: flex; align-items: center; gap: 15px;">
-                <button id="connectBtn" style="padding: 10px 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 14px;">
-                    Connect to Agent
-                </button>
-                <span id="liveStatus" style="color: #666; font-size: 13px;"></span>
-                <details style="margin-left: auto;">
-                    <summary style="cursor: pointer; color: #666; font-size: 13px;">Advanced</summary>
-                    <div style="position: absolute; right: 20px; background: white; padding: 15px; border-radius: 6px; box-shadow: 0 4px 12px rgba(0,0,0,0.15); margin-top: 10px; z-index: 100;">
-                        <div style="margin-bottom: 10px;">
-                            <label for="fileInput" style="font-weight: 500; display: block; margin-bottom: 5px;">Load from file:</label>
-                            <input type="file" id="fileInput" accept=".jsonl">
-                        </div>
-                        <div>
-                            <label for="urlInput" style="font-weight: 500; display: block; margin-bottom: 5px;">Custom URL:</label>
-                            <input type="text" id="urlInput" placeholder="http://localhost:8000/..." style="width: 300px; padding: 6px; border: 1px solid #ddd; border-radius: 4px;">
-                        </div>
-                    </div>
-                </details>
-            </div>
-        </div>
-        <!-- Hidden inputs for backward compatibility -->
-        <input type="file" id="tokenFileInput" accept=".jsonl" style="display: none;">
-        <input type="text" id="sessionUrlInput" style="display: none;">
-
-        <div id="statsContainer" class="stats" style="display: none;"></div>
-
-        <div class="tabs">
-            <button class="tab active" data-tab="timeline">Timeline View</button>
-            <button class="tab" data-tab="lifespan">Lifespan View</button>
-            <button class="tab" data-tab="reasoning">Reasoning Patterns</button>
-            <button class="tab" data-tab="graph">Graph Nodes</button>
-            <button class="tab" data-tab="analysis">Tool Usage Analysis</button>
-            <button class="tab" data-tab="clustering">Resource Clustering</button>
-            <button class="tab" data-tab="text">Text Analysis</button>
-            <button class="tab" data-tab="tokens">Token Tracking</button>
-        </div>
-
-        <div id="timeline" class="tab-content active">
-            <div class="filter-controls" id="timelineFilters"></div>
-            <div class="visualization">
-                <div id="timelineContainer"></div>
-            </div>
-        </div>
-
-        <div id="lifespan" class="tab-content">
-            <div class="filter-controls" id="lifespanFilters"></div>
-            <div class="visualization">
-                <svg id="lifespanChart"></svg>
-            </div>
-        </div>
-
-        <div id="reasoning" class="tab-content">
-            <div class="visualization">
-                <h3 style="margin-bottom: 15px;">Reasoning Pattern Analysis</h3>
-                <p style="color: #666; margin-bottom: 15px;">
-                    Analyzes the reasoning strategies used by agents: one-shot, chain-of-thought, ReAct (tool use loops), multi-turn, and extended thinking.
-                </p>
-                <div id="reasoningStatsContainer" class="stats" style="margin-bottom: 20px;"></div>
-                <div id="reasoningContainer"></div>
-            </div>
-        </div>
-
-        <div id="graph" class="tab-content">
-            <div class="visualization">
-                <h3 style="margin-bottom: 15px;">LangGraph Node Transitions</h3>
-                <p style="color: #666; margin-bottom: 15px;">
-                    Visualizes the execution flow through LangGraph nodes including agent, tools, and routing decisions.
-                </p>
-                <div id="graphStatsContainer" class="stats" style="margin-bottom: 20px;"></div>
-                <div id="graphNodeContainer"></div>
-            </div>
-        </div>
-
-        <div id="analysis" class="tab-content">
-            <div class="visualization">
-                <div id="analysisContainer"></div>
-            </div>
-        </div>
-
-        <div id="clustering" class="tab-content">
-            <div class="visualization">
-                <div style="margin-bottom: 15px;">
-                    <h3 style="margin-bottom: 10px;">Interactive Resource Clustering</h3>
-                    <p style="color: #666; margin-bottom: 15px;">
-                        Tool calls are clustered based on shared resources (files, directories, patterns).
-                        Hover over nodes for details, drag to reposition.
-                    </p>
-                    <div class="filter-controls">
-                        <div class="filter-group">
-                            <label>Cluster By:</label>
-                            <select id="clusterBy">
-                                <option value="directory">Directory</option>
-                                <option value="file">Exact File</option>
-                                <option value="agent">Agent</option>
-                            </select>
-                        </div>
-                        <div class="filter-group">
-                            <label>Min Links:</label>
-                            <select id="minLinks">
-                                <option value="1">1+ connections</option>
-                                <option value="2" selected>2+ connections</option>
-                                <option value="3">3+ connections</option>
-                            </select>
-                        </div>
-                        <div class="filter-group">
-                            <label>Toggle By Agent: <small style="color: #666;">(Ctrl/Cmd+Click for multiple)</small></label>
-                            <select id="filterAgent" multiple size="6" style="min-width: 180px;">
-                                <option value="" selected>All Agents</option>
-                            </select>
-                            <div style="display: flex; gap: 5px; margin-top: 5px;">
-                                <button class="select-all-btn" data-target="filterAgent" style="flex: 1; padding: 4px 8px; font-size: 12px; cursor: pointer; background: #4CAF50; color: white; border: none; border-radius: 3px;">All</button>
-                                <button class="select-none-btn" data-target="filterAgent" style="flex: 1; padding: 4px 8px; font-size: 12px; cursor: pointer; background: #757575; color: white; border: none; border-radius: 3px;">None</button>
-                            </div>
-                        </div>
-                        <div class="filter-group">
-                            <label>Filter by Directory: <small style="color: #666;">(Ctrl/Cmd+Click for multiple)</small></label>
-                            <select id="filterDirectory" multiple size="6" style="min-width: 250px;">
-                                <option value="" selected>All Directories</option>
-                            </select>
-                            <div style="display: flex; gap: 5px; margin-top: 5px;">
-                                <button class="select-all-btn" data-target="filterDirectory" style="flex: 1; padding: 4px 8px; font-size: 12px; cursor: pointer; background: #4CAF50; color: white; border: none; border-radius: 3px;">All</button>
-                                <button class="select-none-btn" data-target="filterDirectory" style="flex: 1; padding: 4px 8px; font-size: 12px; cursor: pointer; background: #757575; color: white; border: none; border-radius: 3px;">None</button>
-                            </div>
-                        </div>
-                        <div class="filter-group">
-                            <label>Filter by File: <small style="color: #666;">(Ctrl/Cmd+Click for multiple)</small></label>
-                            <select id="filterFile" multiple size="6" style="min-width: 250px;">
-                                <option value="" selected>All Files</option>
-                            </select>
-                            <div style="display: flex; gap: 5px; margin-top: 5px;">
-                                <button class="select-all-btn" data-target="filterFile" style="flex: 1; padding: 4px 8px; font-size: 12px; cursor: pointer; background: #4CAF50; color: white; border: none; border-radius: 3px;">All</button>
-                                <button class="select-none-btn" data-target="filterFile" style="flex: 1; padding: 4px 8px; font-size: 12px; cursor: pointer; background: #757575; color: white; border: none; border-radius: 3px;">None</button>
-                            </div>
-                        </div>
-                        <div class="filter-group" style="align-self: flex-end;">
-                            <button id="clearClusterFilters" style="padding: 8px 16px; cursor: pointer; background: #f44336; color: white; border: none; border-radius: 4px; font-size: 14px;">
-                                Clear Filters
-                            </button>
-                        </div>
-                    </div>
-                </div>
-                <svg id="clusterGraph"></svg>
-                <div class="cluster-legend" id="clusterLegend"></div>
-            </div>
-        </div>
-
-        <div id="text" class="tab-content">
-            <div class="visualization">
-                <h3 style="margin-bottom: 15px;">Text Block Analysis</h3>
-                <div id="textStatsContainer" class="stats" style="margin-bottom: 20px;"></div>
-                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px;">
-                    <div>
-                        <h4 style="margin-bottom: 10px;">Text Frequency Over Time</h4>
-                        <svg id="textFrequencyChart"></svg>
-                    </div>
-                    <div>
-                        <h4 style="margin-bottom: 10px;">Text Length Distribution</h4>
-                        <svg id="textLengthChart"></svg>
-                    </div>
-                </div>
-                <div style="margin-top: 20px;">
-                    <h4 style="margin-bottom: 10px;">Text Output by Agent</h4>
-                    <svg id="textByAgentChart"></svg>
-                </div>
-            </div>
-        </div>
-
-        <div id="tokens" class="tab-content">
-            <div class="visualization">
-                <h3 style="margin-bottom: 15px;">Token Usage Tracking</h3>
-                <div id="tokenStatsContainer" class="stats" style="margin-bottom: 20px;"></div>
-                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px;">
-                    <div>
-                        <h4 style="margin-bottom: 10px;">Token Usage Over Time</h4>
-                        <svg id="tokenChart"></svg>
-                    </div>
-                    <div>
-                        <h4 style="margin-bottom: 10px;">Cache Efficiency</h4>
-                        <svg id="cacheChart"></svg>
-                    </div>
-                </div>
-                <div style="margin-top: 20px;">
-                    <h4 style="margin-bottom: 10px;">Cumulative Token Usage (Input vs Output)</h4>
-                    <svg id="cumulativeChart"></svg>
-                </div>
-            </div>
-        </div>
-
-        <div id="loading" class="loading" style="display: none;">
-            Loading and processing data...
-        </div>
-    </div>
-
-    <div class="tooltip" id="tooltip" style="display: none;"></div>
-
-    <script>
-        // Global state
-        let allEvents = [];
-        let toolCallData = [];
-        let agentLifespans = {};
-        let tokenData = [];
-        const toolColors = d3.scaleOrdinal(d3.schemeTableau10);
-        const weightColorScale = d3.scaleThreshold()
-            .domain([3, 6, 9])
-            .range(['#90EE90', '#FFD700', '#FFA500', '#FF4500']);
-
-        // Tab switching
-        document.querySelectorAll('.tab').forEach(tab => {
-            tab.addEventListener('click', () => {
-                document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
-                document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
-                tab.classList.add('active');
-                document.getElementById(tab.dataset.tab).classList.add('active');
-            });
-        });
-
-        // Clustering filter listeners (will be attached after data loads)
-        function attachClusteringListeners() {
-            const clusterBy = document.getElementById('clusterBy');
-            const minLinks = document.getElementById('minLinks');
-            const filterAgent = document.getElementById('filterAgent');
-            const filterDirectory = document.getElementById('filterDirectory');
-            const filterFile = document.getElementById('filterFile');
-            const clearButton = document.getElementById('clearClusterFilters');
-
-            if (clusterBy) clusterBy.addEventListener('change', renderClustering);
-            if (minLinks) minLinks.addEventListener('change', renderClustering);
-            if (filterAgent) filterAgent.addEventListener('change', renderClustering);
-            if (filterDirectory) filterDirectory.addEventListener('change', renderClustering);
-            if (filterFile) filterFile.addEventListener('change', renderClustering);
-
-            if (clearButton) {
-                clearButton.addEventListener('click', () => {
-                    // Clear all filter selections
-                    if (filterAgent) {
-                        Array.from(filterAgent.options).forEach(opt => opt.selected = opt.value === '');
-                    }
-                    if (filterDirectory) {
-                        Array.from(filterDirectory.options).forEach(opt => opt.selected = opt.value === '');
-                    }
-                    if (filterFile) {
-                        Array.from(filterFile.options).forEach(opt => opt.selected = opt.value === '');
-                    }
-                    renderClustering();
-                });
-            }
-
-            // Select All / None buttons
-            document.querySelectorAll('.select-all-btn').forEach(btn => {
-                btn.addEventListener('click', () => {
-                    const targetId = btn.getAttribute('data-target');
-                    const select = document.getElementById(targetId);
-                    if (select) {
-                        Array.from(select.options).forEach(opt => {
-                            if (opt.value !== '') opt.selected = true;
-                        });
-                        renderClustering();
-                    }
-                });
-            });
-
-            document.querySelectorAll('.select-none-btn').forEach(btn => {
-                btn.addEventListener('click', () => {
-                    const targetId = btn.getAttribute('data-target');
-                    const select = document.getElementById(targetId);
-                    if (select) {
-                        Array.from(select.options).forEach(opt => opt.selected = opt.value === '');
-                        renderClustering();
-                    }
-                });
-            });
-        }
-
-        // File input handler (advanced mode)
-        document.getElementById('fileInput').addEventListener('change', (e) => {
-            const file = e.target.files[0];
-            if (file) {
-                loadAndProcessFile(file);
-            }
-        });
-
-        // Token file input handler (hidden, for backward compatibility)
-        document.getElementById('tokenFileInput').addEventListener('change', (e) => {
-            const file = e.target.files[0];
-            if (file) {
-                loadAndProcessTokenFile(file);
-            }
-        });
-
-        // Live monitoring state
-        let liveMonitorInterval = null;
-        let toolUsageEndpoint = null;
-        let currentUrl = null;
-        let lastEventCount = 0;
-        let isConnected = false;
-
-        // Connect button handler
-        document.getElementById('connectBtn').addEventListener('click', () => {
-            if (isConnected) {
-                disconnectFromAgent();
-            } else {
-                connectToAgent();
-            }
-        });
-
-        // Connect to agent - auto-discover and start monitoring
-        async function connectToAgent() {
-            const btn = document.getElementById('connectBtn');
-            btn.textContent = 'Connecting...';
-            btn.disabled = true;
-            updateLiveStatus('Connecting to agent...');
-
-            // Try multiple ports in case default is in use
-            const ports = [8888, 8000, 8080, 3000];
-            let response = null;
-            let serverPort = null;
-            
-            for (const port of ports) {
-                try {
-                    const testResponse = await fetch(`http://localhost:${port}/get/tool_calls_file`, {
-                        signal: AbortSignal.timeout(1000)
-                    });
-                    if (testResponse.ok) {
-                        const data = await testResponse.json();
-                        if (data.tool_calls_file) {
-                            response = testResponse;
-                            serverPort = port;
-                            break;
-                        }
-                    }
-                } catch (e) {
-                    // Try next port
-                }
-            }
-
-            try {
-                if (!serverPort) {
-                    throw new Error('No server found on ports ' + ports.join(', '));
-                }
-                
-                // Re-fetch since we consumed the response
-                response = await fetch(`http://localhost:${serverPort}/get/tool_calls_file`);
-                
-                if (response.ok) {
-                    const data = await response.json();
-                    
-                    if (data.tool_calls_file) {
-                        const toolCallsUrl = `http://localhost:${serverPort}/${data.tool_calls_file}`;
-                        document.getElementById('urlInput').value = toolCallsUrl;
-                        
-                        currentUrl = toolCallsUrl;
-                        toolUsageEndpoint = toolCallsUrl;
-                        
-                        // Load initial data
-                        await loadToolCallsFromURL(toolCallsUrl);
-                        
-                        // Start live monitoring
-                        startLiveToolCallMonitoring();
-                        
-                        isConnected = true;
-                        btn.textContent = 'Disconnect';
-                        btn.style.background = 'linear-gradient(135deg, #f5576c 0%, #f093fb 100%)';
-                        updateLiveStatus('Connected - Live monitoring active');
-                    } else {
-                        throw new Error('No active session found');
-                    }
-                } else {
-                    throw new Error('Server not responding');
-                }
-            } catch (error) {
-                console.error('Connection failed:', error);
-                updateLiveStatus(`Connection failed: ${error.message}`);
-                btn.textContent = 'Connect to Agent';
-                btn.disabled = false;
-                
-                // Show helpful message
-                document.getElementById('loading').style.display = 'block';
-                document.getElementById('loading').innerHTML = `
-                    <div style="color: #666; padding: 40px; text-align: center;">
-                        <h3 style="margin-bottom: 15px;">Could not connect to agent</h3>
-                        <p style="margin-bottom: 20px;">Make sure the log server is running:</p>
-                        <code style="display: block; background: #f5f5f5; padding: 15px; border-radius: 6px; margin-bottom: 20px;">
-                            cd observability && ./live_monitor.sh
-                        </code>
-                        <p style="color: #999; font-size: 13px;">Or use the Advanced menu to load a file manually.</p>
-                    </div>
-                `;
-            }
-            
-            btn.disabled = false;
-        }
-
-        // Disconnect from agent
-        function disconnectFromAgent() {
-            stopLiveMonitoring();
-            isConnected = false;
-            
-            const btn = document.getElementById('connectBtn');
-            btn.textContent = 'Connect to Agent';
-            btn.style.background = 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)';
-            updateLiveStatus('Disconnected');
-        }
-
-        // Auto-connect on page load
-        async function autoConnect() {
-            // Try multiple ports
-            const ports = [8888, 8000, 8080, 3000];
-            
-            for (const port of ports) {
-                try {
-                    const response = await fetch(`http://localhost:${port}/get/tool_calls_file`, {
-                        signal: AbortSignal.timeout(1000)
-                    });
-                    
-                    if (response.ok) {
-                        const data = await response.json();
-                        if (data.tool_calls_file) {
-                            // Server is running with active session, auto-connect
-                            connectToAgent();
-                            return;
-                        }
-                    }
-                } catch (error) {
-                    // Try next port
-                }
-            }
-            console.log('Auto-connect: no server found');
-        }
-
-        // Call auto-connect when page loads
-        autoConnect();
-
-        // Load data from URL
-        async function loadToolCallsFromURL(url) {
-            try {
-                console.log('Loading from URL:', url);
-                document.getElementById('loading').style.display = 'block';
-                document.getElementById('loading').innerHTML = 'Loading from URL...';
-
-                // Add timeout to prevent hanging
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
-
-                const response = await fetch(url, { signal: controller.signal });
-                clearTimeout(timeoutId);
-                console.log('Response status:', response.status, response.statusText);
-
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-
-                const text = await response.text();
-                console.log('Received text, length:', text.length);
-
-                const lines = text.split('\n');
-                console.log('Split into lines:', lines.length);
-
-                allEvents = [];
-                let parseErrors = 0;
-                lines.forEach((line, index) => {
-                    if (line.trim()) {
-                        try {
-                            allEvents.push(JSON.parse(line));
-                        } catch (e) {
-                            parseErrors++;
-                            console.warn(`Failed to parse line ${index + 1}:`, e.message, line.substring(0, 100));
-                        }
-                    }
-                });
-
-                console.log('Parsed events:', allEvents.length, 'Parse errors:', parseErrors);
-
-                if (allEvents.length === 0) {
-                    throw new Error('No valid events found in file. Check console for parse errors.');
-                }
-
-                lastEventCount = allEvents.length;
-                console.log('Processing data...');
-                processData();
-
-                console.log('Tool call data:', toolCallData.length);
-
-                if (toolCallData.length === 0) {
-                    // No tool calls yet, but this is okay - show waiting message
-                    document.getElementById('loading').style.display = 'block';
-                    document.getElementById('loading').innerHTML =
-                        `<div style="color: #666; padding: 20px; text-align: center;">
-                            <strong>⏳ Waiting for tool calls...</strong><br><br>
-                            <small>Session loaded with ${allEvents.length} events (text/thinking blocks only).</small><br>
-                            <small>Tool call data will appear here once the agent starts using tools.</small><br>
-                            <small>Live monitoring is active and will auto-update.</small>
-                        </div>`;
-                    updateLiveStatus(`⏳ Waiting for tool calls (${allEvents.length} events loaded)`);
-                    console.log('No tool calls yet - waiting for data...');
-                } else {
-                    // We have tool calls, render them
-                    console.log('Rendering...');
-                    try {
-                        renderAll();
-                        document.getElementById('loading').style.display = 'none';
-                        document.getElementById('statsContainer').style.display = 'grid';
-                        updateLiveStatus(`✅ Loaded ${allEvents.length} events`);
-                        console.log('Load complete!');
-                    } catch (renderError) {
-                        throw new Error(`Rendering failed: ${renderError.message}`);
-                    }
-                }
-            } catch (error) {
-                let errorMessage = error.message;
-                if (error.name === 'AbortError') {
-                    errorMessage = 'Request timed out after 30 seconds. The server might be slow or unresponsive.';
-                }
-
-                document.getElementById('loading').style.display = 'block';
-                document.getElementById('loading').innerHTML =
-                    `<div class="error">
-                        <strong>Error loading from URL:</strong><br>
-                        ${errorMessage}<br><br>
-                        <small>Check browser console (F12) for details</small><br>
-                        <small>Common issues:</small><br>
-                        <small>• File not found (404 error)</small><br>
-                        <small>• CORS error (blocked by browser security)</small><br>
-                        <small>• Invalid JSONL format (check console for parse errors)</small><br>
-                        <small>• Network timeout (server too slow)</small><br>
-                        <small>• Server CORS headers missing</small>
-                    </div>`;
-                console.error('Error loading from URL:', error);
-                console.error('Error name:', error.name);
-                console.error('Full error details:', error.stack);
-            }
-        }
-
-        // Start live monitoring
-        function startLiveToolCallMonitoring() {
-            updateLiveStatus('🔴 Live monitoring...');
-            liveMonitorInterval = setInterval(async () => {
-                try {
-                    const response = await fetch(toolUsageEndpoint);
-                    if (!response.ok) return;
-
-                    const text = await response.text();
-                    const lines = text.split('\n');
-                    const newEvents = lines
-                        .filter(line => line.trim())
-                        .map(line => JSON.parse(line));
-
-                    if (newEvents.length > lastEventCount) {
-                        // New events detected
-                        allEvents = newEvents;
-                        lastEventCount = newEvents.length;
-                        processData();
-
-                        // Only render if we have tool call data
-                        if (toolCallData.length > 0) {
-                            renderAll();
-                            document.getElementById('loading').style.display = 'none';
-                            document.getElementById('statsContainer').style.display = 'grid';
-                            updateLiveStatus(`🔴 Live (${allEvents.length} events, updated ${new Date().toLocaleTimeString()})`);
-                        } else {
-                            // Still waiting for tool calls
-                            document.getElementById('loading').innerHTML =
-                                `<div style="color: #666; padding: 20px; text-align: center;">
-                                    <strong>⏳ Waiting for tool calls...</strong><br><br>
-                                    <small>Session loaded with ${allEvents.length} events (text/thinking blocks only).</small><br>
-                                    <small>Tool call data will appear here once the agent starts using tools.</small><br>
-                                    <small>Live monitoring is active and will auto-update.</small>
-                                </div>`;
-                            updateLiveStatus(`⏳ Waiting for tool calls (${allEvents.length} events, updated ${new Date().toLocaleTimeString()})`);
-                        }
-                    }
-                } catch (error) {
-                    console.error('Live monitor error:', error);
-                    updateLiveStatus(`⚠️ Error: ${error.message}`);
-                }
-            }, 2000); // Poll every 2 seconds
-        }
-
-        // Stop live monitoring
-        function stopLiveMonitoring() {
-            if (liveMonitorInterval) {
-                clearInterval(liveMonitorInterval);
-                liveMonitorInterval = null;
-                updateLiveStatus('⏸️ Monitoring stopped');
-            }
-        }
-
-        // Update live status indicator
-        function updateLiveStatus(message) {
-            const statusElement = document.getElementById('liveStatus');
-            if (statusElement) {
-                statusElement.textContent = message;
-            }
-        }
-
-        // Context weight calculation functions
-        function getBashCommandWeight(command) {
-            if (!command) return 2;
-            const cmd = command.trim().toLowerCase();
-
-            // File discovery & listing
-            if (/^(ls|find|tree|fd)\b/.test(cmd)) {
-                const hasLimits = ['-maxdepth', 'head', '| head', 'tail', '| tail', '-L '].some(p => cmd.includes(p));
-                if (!hasLimits && (cmd.includes('find') || cmd.includes('tree'))) return 10;
-                return hasLimits ? 7 : 9;
-            }
-
-            // Content viewing
-            if (/^(cat|less|bat|more)\b/.test(cmd)) {
-                if (cmd.includes('cat') && !['head', 'tail', '|'].some(l => cmd.includes(l))) return 9;
-                return 5;
-            }
-
-            if (/^(head|tail)\b/.test(cmd)) return 5;
-            if (cmd.includes('sed') && /-n.*p/.test(cmd)) return 6;
-
-            // Search
-            if (/^(grep|rg|ripgrep|ack|ag)\b/.test(cmd)) {
-                const hasLimits = ['--max-count', '-m ', 'head', '| head', '--glob'].some(p => cmd.includes(p));
-                const excludesBloat = ['!node_modules', '!vendor', '!target', '--glob'].some(e => cmd.includes(e));
-                if (!hasLimits && !excludesBloat) return 10;
-                return hasLimits ? 7 : 9;
-            }
-
-            // JSON/YAML
-            if (['jq', 'yq', 'json.dumps', 'JSON.stringify'].some(t => cmd.includes(t))) {
-                const isCompact = ['-c', 'compact', '{', 'paths'].some(f => cmd.includes(f));
-                return isCompact ? 7 : 9;
-            }
-
-            // Git
-            if (cmd.startsWith('git ')) {
-                if (['status', 'log --oneline', 'branch', 'remote'].some(s => cmd.includes(s))) return 3;
-                if (['diff --stat', 'show --name-only', 'log -'].some(m => cmd.includes(m))) return 5;
-                if (cmd.includes('diff') || cmd.includes('show') || cmd.includes('log -p')) return 8;
-                return 4;
-            }
-
-            // Build/test
-            if (['test', 'make', 'cargo build', 'npm run', 'go test', 'pytest'].some(t => cmd.includes(t))) {
-                const hasLimit = ['tail', 'head', '>', '2>&1'].some(l => cmd.includes(l));
-                return hasLimit ? 7 : 9;
-            }
-
-            // Network
-            if (/^(curl|wget)\b/.test(cmd)) {
-                const isHeadersOnly = ['-I', '--head', '-s'].some(f => cmd.includes(f));
-                const hasLimits = cmd.includes('| head') || cmd.includes('| tail');
-                return isHeadersOnly ? 5 : (hasLimits ? 6 : 8);
-            }
-
-            if (/^(ps|top|lsof|netstat)\b/.test(cmd)) {
-                const hasFilter = ['grep', 'rg', '| head', '| tail'].some(f => cmd.includes(f));
-                return hasFilter ? 6 : 8;
-            }
-
-            // Archive
-            if (['tar -', 'unzip', 'xxd', 'strings', 'objdump'].some(t => cmd.includes(t))) {
-                const isListOnly = ['-l', '-t', '--list'].some(f => cmd.includes(f));
-                return isListOnly ? 7 : 9;
-            }
-
-            return 5;
-        }
-
-        function getToolBaseWeight(toolName, toolInput) {
-            if (toolName === 'Bash') {
-                return getBashCommandWeight(toolInput.command || '');
-            }
-
-            if (['Clock', 'GetMetadata', 'SimpleStatus'].includes(toolName)) return 2;
-            if (['Search', 'Query', 'Lookup'].includes(toolName)) return 5;
-
-            if (toolName === 'Read') {
-                const filePath = toolInput.file_path || '';
-                const dangerous = ['node_modules', 'vendor', 'package-lock', 'yarn.lock', '.min.', 'dist/', 'build/'];
-                if (dangerous.some(d => filePath.toLowerCase().includes(d))) return 9;
-
-                const binary = ['.png', '.jpg', '.pdf', '.zip', '.tar', '.so', '.dll', '.exe'];
-                if (binary.some(ext => filePath.includes(ext))) return 8;
-
-                const limit = toolInput.limit;
-                if (limit && limit <= 200) return 4;
-                if (limit) return 6;
-                return 7;
-            }
-
-            if (['Write', 'Edit', 'Create', 'Update', 'Delete'].includes(toolName)) return 3;
-
-            if (['Glob', 'Find', 'Grep'].includes(toolName)) {
-                const pattern = toolInput.pattern || '';
-                if (pattern.includes('**') || pattern.includes('*/*')) return 8;
-                return 6;
-            }
-
-            if (['Task', 'Spawn', 'SubAgent'].includes(toolName)) return 5;
-
-            return 5;
-        }
-
-        function calculateOutputFactor(outputSize) {
-            if (!outputSize) return 1.5;
-            const approxLines = outputSize / 80;
-            if (approxLines <= 200) return 1.0;
-            if (approxLines <= 800) return 1.5;
-            return 2.0;
-        }
-
-        function calculateContextWeight(toolName, toolInput, outputSize) {
-            const baseWeight = getToolBaseWeight(toolName, toolInput);
-            const outputFactor = calculateOutputFactor(outputSize);
-            return Math.min(10.0, baseWeight * outputFactor);
-        }
-
-        function getWeightCategory(weight) {
-            if (weight <= 2) return { label: 'Negligible', color: '#90EE90', class: 'negligible' };
-            if (weight <= 5) return { label: 'Moderate', color: '#FFD700', class: 'moderate' };
-            if (weight <= 8) return { label: 'Heavy', color: '#FFA500', class: 'heavy' };
-            return { label: 'Critical', color: '#FF4500', class: 'critical' };
-        }
-
-        // Load session log from URL
-        async function loadSessionFromUrl(url) {
-            try {
-                console.log('Loading session log from URL:', url);
-
-                // Add timeout to prevent hanging
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
-
-                const response = await fetch(url, { signal: controller.signal });
-                clearTimeout(timeoutId);
-                console.log('Session log response status:', response.status, response.statusText);
-
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-
-                const text = await response.text();
-                console.log('Received session log text, length:', text.length);
-
-                const lines = text.split('\n');
-                console.log('Split into lines:', lines.length);
-
-                // Parse token/session data (same logic as loadAndProcessTokenFile)
-                tokenData = lines
-                    .filter(line => line.trim())
-                    .map(line => {
-                        try {
-                            return JSON.parse(line);
-                        } catch (err) {
-                            return null;
-                        }
-                    })
-                    .filter(entry => entry && entry.message && entry.message.usage)
-                    .map(entry => ({
-                        timestamp: new Date(entry.timestamp),
-                        inputTokens: entry.message.usage.input_tokens || 0,
-                        cacheRead: entry.message.usage.cache_read_input_tokens || 0,
-                        cacheCreation: entry.message.usage.cache_creation_input_tokens || 0,
-                        outputTokens: entry.message.usage.output_tokens || 0
-                    }));
-
-                // Sort by timestamp
-                tokenData.sort((a, b) => a.timestamp - b.timestamp);
-
-                // Add cumulative totals
-                let cumInput = 0, cumCacheRead = 0, cumCacheCreation = 0, cumOutput = 0;
-                tokenData.forEach(d => {
-                    cumInput += d.inputTokens;
-                    cumCacheRead += d.cacheRead;
-                    cumCacheCreation += d.cacheCreation;
-                    cumOutput += d.outputTokens;
-                    d.cumInputTokens = cumInput;
-                    d.cumCacheRead = cumCacheRead;
-                    d.cumCacheCreation = cumCacheCreation;
-                    d.cumOutputTokens = cumOutput;
-                    d.cumTotal = cumInput + cumCacheRead + cumCacheCreation + cumOutput;
-                });
-
-                console.log('Parsed token data entries:', tokenData.length);
-
-                if (tokenData.length === 0) {
-                    console.warn('No valid token data found in session log. Make sure the file contains usage information.');
-                } else {
-                    renderTokenTracking();
-                    console.log(`✅ Loaded ${tokenData.length} session log entries with token data`);
-                }
-
-            } catch (error) {
-                let errorMessage = error.message;
-                if (error.name === 'AbortError') {
-                    errorMessage = 'Request timed out after 30 seconds. The server might be slow or unresponsive.';
-                }
-
-                console.error(`Error loading session log from URL: ${errorMessage}`);
-                console.error('Full error:', error);
-                // Re-throw so caller can handle it
-                throw error;
-            }
-        }
-
-        // Load and process file
-        function loadAndProcessFile(file) {
-            document.getElementById('loading').style.display = 'block';
-            document.getElementById('loading').innerHTML = 'Loading...';
-
-            const reader = new FileReader();
-            reader.onload = (e) => {
-                try {
-                    const lines = e.target.result.split('\n');
-                    allEvents = lines
-                        .filter(line => line.trim())
-                        .map(line => JSON.parse(line));
-
-                    if (allEvents.length === 0) {
-                        throw new Error('No events found in file');
-                    }
-
-                    processData();
-
-                    if (toolCallData.length === 0) {
-                        throw new Error('No tool call events found. Make sure this is a tool_calls.jsonl file.');
-                    }
-
-                    renderAll();
-                    document.getElementById('loading').style.display = 'none';
-                    document.getElementById('statsContainer').style.display = 'grid';
-                } catch (error) {
-                    document.getElementById('loading').style.display = 'block';
-                    document.getElementById('loading').innerHTML =
-                        `<div class="error">Error loading file: ${error.message}</div>`;
-                    console.error('Error loading file:', error);
-                }
-            };
-            reader.readAsText(file);
-        }
-
-        // Global data arrays
-        let textBlockData = [];
-        let thinkingBlockData = [];
-        let graphNodeData = [];
-        let llmEventData = [];
-        let subagentEventData = [];
-
-        // Process data
-        function processData() {
-            const toolCallStarts = {};
-            const toolCallCompletes = {};
-            const llmStartEvents = {};  // For backwards compatibility with old logs
-
-            // Clear previous data
-            textBlockData = [];
-            thinkingBlockData = [];
-            graphNodeData = [];
-            llmEventData = [];
-            subagentEventData = [];
-
-            allEvents.forEach(event => {
-                if (event.event === 'tool_call_start') {
-                    toolCallStarts[event.tool_use_id] = event;
-                } else if (event.event === 'tool_call_complete') {
-                    toolCallCompletes[event.tool_use_id] = event;
-                } else if (event.event === 'text_block') {
-                    textBlockData.push({
-                        timestamp: new Date(event.timestamp),
-                        agentId: event.agent_id,
-                        agentType: event.agent_type,
-                        text: event.text,
-                        textLength: event.text_length,
-                        parentToolUseId: event.parent_tool_use_id
-                    });
-                } else if (event.event === 'thinking_block') {
-                    thinkingBlockData.push({
-                        timestamp: new Date(event.timestamp),
-                        agentId: event.agent_id,
-                        agentType: event.agent_type,
-                        thinking: event.thinking,
-                        thinkingLength: event.thinking_length,
-                        parentToolUseId: event.parent_tool_use_id
-                    });
-                } else if (event.event === 'graph_node_start' || event.event === 'graph_node_end') {
-                    // LangGraph node transition events
-                    graphNodeData.push({
-                        event: event.event,
-                        timestamp: new Date(event.timestamp),
-                        nodeName: event.node_name,
-                        graphId: event.graph_id,
-                        agentId: event.agent_id,
-                        runId: event.run_id
-                    });
-                } else if (event.event === 'llm_complete') {
-                    // LLM completion events with token usage AND reasoning pattern (from LangGraph callbacks)
-                    // Reasoning pattern is now included directly in llm_complete, no correlation needed
-                    llmEventData.push({
-                        timestamp: new Date(event.timestamp),
-                        runId: event.run_id,
-                        agentId: event.agent_id,
-                        agentType: event.agent_type,
-                        graphNode: event.graph_node,
-                        inputTokens: event.input_tokens || 0,
-                        outputTokens: event.output_tokens || 0,
-                        cacheRead: event.cache_read_tokens || 0,
-                        cacheCreation: event.cache_creation_tokens || 0,
-                        totalInputTokens: event.total_input_tokens || 0,
-                        totalOutputTokens: event.total_output_tokens || 0,
-                        model: event.model || 'unknown',
-                        responseAnalysis: event.response_analysis || {},
-                        reasoningPattern: event.reasoning_pattern || {},
-                        durationMs: event.duration_ms,
-                    });
-                } else if (event.event === 'llm_start') {
-                    // LLM start events - now primarily for backwards compatibility
-                    // Reasoning pattern is also captured in llm_complete
-                    llmStartEvents[event.run_id] = {
-                        timestamp: new Date(event.timestamp),
-                        runId: event.run_id,
-                        agentId: event.agent_id,
-                        graphNode: event.graph_node,
-                        reasoningPattern: event.reasoning_pattern || {},
-                        model: event.model,
-                    };
-                } else if (event.event === 'subagent_spawn' || event.event === 'subagent_complete') {
-                    // Subagent lifecycle events
-                    subagentEventData.push({
-                        event: event.event,
-                        timestamp: new Date(event.timestamp),
-                        agentId: event.agent_id || event.subagent_id,
-                        subagentType: event.subagent_type || event.agent_type,
-                        description: event.description,
-                        toolCalls: event.tool_calls,
-                        duration: event.duration
-                    });
-                } else if (event.event === 'layer_start' || event.event === 'layer_complete') {
-                    // Layer-based parallel orchestration events
-                    if (!window.layerEventData) window.layerEventData = [];
-                    window.layerEventData.push({
-                        event: event.event,
-                        timestamp: new Date(event.timestamp),
-                        layerIndex: event.layer_index,
-                        totalLayers: event.total_layers,
-                        componentCount: event.component_count,
-                        components: event.components || [],
-                        successful: event.successful,
-                        failed: event.failed,
-                        durationSeconds: event.duration_seconds,
-                        results: event.results || []
-                    });
-                } else if (event.event === 'orchestration_start' || event.event === 'orchestration_complete') {
-                    // Overall orchestration events
-                    if (!window.orchestrationEvents) window.orchestrationEvents = [];
-                    window.orchestrationEvents.push({
-                        event: event.event,
-                        timestamp: new Date(event.timestamp),
-                        totalComponents: event.total_components,
-                        totalLayers: event.total_layers,
-                        layerSizes: event.layer_sizes,
-                        totalDurationSeconds: event.total_duration_seconds,
-                        successful: event.successful,
-                        failed: event.failed
-                    });
-                }
-            });
-            
-            // Post-process: merge llm_start data into llm_complete events for backwards compatibility
-            // (Old logs may not have reasoning_pattern in llm_complete)
-            llmEventData.forEach(event => {
-                if (!event.reasoningPattern || !event.reasoningPattern.type) {
-                    const startEvent = llmStartEvents[event.runId];
-                    if (startEvent && startEvent.reasoningPattern) {
-                        event.reasoningPattern = startEvent.reasoningPattern;
-                    }
-                }
-            });
-
-            // Use LLM events for token tracking (from LangGraph callbacks)
-            // This is the primary source now - the tool_calls.jsonl contains everything
-            if (llmEventData.length > 0) {
-                // Sort by timestamp
-                llmEventData.sort((a, b) => a.timestamp - b.timestamp);
-                
-                // Calculate cumulative values if not provided
-                let cumInput = 0, cumOutput = 0, cumCacheRead = 0, cumCacheCreation = 0;
-                
-                tokenData = llmEventData.map(d => {
-                    cumInput += d.inputTokens;
-                    cumOutput += d.outputTokens;
-                    cumCacheRead += d.cacheRead;
-                    cumCacheCreation += d.cacheCreation;
-                    
-                    return {
-                        timestamp: d.timestamp,
-                        inputTokens: d.inputTokens,
-                        cacheRead: d.cacheRead,
-                        cacheCreation: d.cacheCreation,
-                        outputTokens: d.outputTokens,
-                        cumInputTokens: d.totalInputTokens || cumInput,
-                        cumOutputTokens: d.totalOutputTokens || cumOutput,
-                        cumCacheRead: cumCacheRead,
-                        cumCacheCreation: cumCacheCreation,
-                        cumTotal: (d.totalInputTokens || cumInput) + (d.totalOutputTokens || cumOutput),
-                        model: d.model
-                    };
-                });
-            }
-
-            toolCallData = Object.entries(toolCallStarts).map(([id, startEvent]) => {
-                const completeEvent = toolCallCompletes[id];
-                const outputSize = completeEvent?.output_size;
-                const weight = calculateContextWeight(
-                    startEvent.tool_name,
-                    startEvent.tool_input || {},
-                    outputSize
-                );
-                const category = getWeightCategory(weight);
-
-                const startTime = new Date(startEvent.timestamp);
-                const completeTime = completeEvent ? new Date(completeEvent.timestamp) : null;
-                const duration = completeTime ? (completeTime - startTime) / 1000 : null;
-
-                return {
-                    id,
-                    agentId: startEvent.agent_id,
-                    agentType: startEvent.agent_type,
-                    toolName: startEvent.tool_name,
-                    toolInput: startEvent.tool_input || {},
-                    timestamp: startTime,
-                    completeTimestamp: completeTime,
-                    duration: duration,
-                    outputSize,
-                    weight,
-                    weightCategory: category,
-                    success: completeEvent?.success,
-                    error: completeEvent?.error
-                };
-            });
-
-            // Calculate agent lifespans
-            agentLifespans = {};
-            allEvents.forEach(event => {
-                if (!event.agent_id) return;
-
-                if (!agentLifespans[event.agent_id]) {
-                    agentLifespans[event.agent_id] = {
-                        start: new Date(event.timestamp),
-                        end: new Date(event.timestamp),
-                        events: []
-                    };
-                } else {
-                    const ts = new Date(event.timestamp);
-                    if (ts < agentLifespans[event.agent_id].start) {
-                        agentLifespans[event.agent_id].start = ts;
-                    }
-                    if (ts > agentLifespans[event.agent_id].end) {
-                        agentLifespans[event.agent_id].end = ts;
-                    }
-                }
-                agentLifespans[event.agent_id].events.push(event);
-            });
-        }
-
-        // Render statistics
-        function renderStats() {
-            const weights = toolCallData.map(d => d.weight);
-            const avgWeight = d3.mean(weights);
-            const criticalCount = weights.filter(w => w > 8).length;
-            const agents = new Set(toolCallData.map(d => d.agentId));
-
-            // Completion metrics
-            const completedCalls = toolCallData.filter(d => d.completeTimestamp);
-            const completionRate = toolCallData.length > 0 ? (completedCalls.length / toolCallData.length * 100) : 0;
-            const durations = completedCalls.map(d => d.duration).filter(d => d !== null);
-            const avgDuration = durations.length > 0 ? d3.mean(durations) : 0;
-            const failedCalls = completedCalls.filter(d => d.success === false).length;
-
-            // Count subagents
-            const subagentSpawns = subagentEventData.filter(e => e.event === 'subagent_spawn').length;
-            const subagentCompletes = subagentEventData.filter(e => e.event === 'subagent_complete').length;
-
-            const stats = [
-                { label: 'Total Tool Calls', value: toolCallData.length, class: 'success' },
-                { label: 'Active Agents', value: agents.size, class: 'success' },
-                { label: 'Subagents Spawned', value: subagentSpawns, class: subagentSpawns > 0 ? 'success' : '' },
-                { label: 'Avg Duration', value: formatTime(avgDuration), class: avgDuration > 5 ? 'warning' : 'success' },
-                { label: 'Failed Calls', value: failedCalls, class: failedCalls > 0 ? 'warning' : 'success' },
-                { label: 'LLM Calls', value: llmEventData.length, class: llmEventData.length > 0 ? 'success' : '' },
-                { label: 'Avg Context Weight', value: avgWeight.toFixed(2), class: avgWeight > 7 ? 'warning' : 'success' }
-            ];
-
-            const container = document.getElementById('statsContainer');
-            container.innerHTML = stats.map(stat => `
-                <div class="stat-card ${stat.class}">
-                    <div class="stat-label">${stat.label}</div>
-                    <div class="stat-value">${stat.value}</div>
-                </div>
-            `).join('');
-        }
-
-        // Render session overview with subagent orchestration
-        function renderSessionOverview(container) {
-            // Get all timestamps for global time range
-            const allTimestamps = [
-                ...toolCallData.map(d => d.timestamp),
-                ...subagentEventData.map(d => d.timestamp)
-            ];
-            
-            if (allTimestamps.length === 0) return;
-            
-            const globalMinTime = d3.min(allTimestamps);
-            const globalMaxTime = d3.max(allTimestamps);
-            const totalDuration = (globalMaxTime - globalMinTime) / 1000;
-
-            // Build subagent timeline data
-            const subagentTimelines = {};
-            subagentEventData.forEach(event => {
-                const agentId = event.agentId;
-                if (!subagentTimelines[agentId]) {
-                    subagentTimelines[agentId] = { spawn: null, complete: null, type: event.subagentType, description: event.description, inputTokens: 0, outputTokens: 0 };
-                }
-                if (event.event === 'subagent_spawn') {
-                    subagentTimelines[agentId].spawn = event.timestamp;
-                    subagentTimelines[agentId].type = event.subagentType;
-                    subagentTimelines[agentId].description = event.description;
-                } else if (event.event === 'subagent_complete') {
-                    subagentTimelines[agentId].complete = event.timestamp;
-                    subagentTimelines[agentId].toolCalls = event.toolCalls;
-                    subagentTimelines[agentId].duration = event.duration;
-                }
-            });
-
-            // Aggregate token usage by agent
-            const tokensByAgent = {};
-            llmEventData.forEach(event => {
-                const agentId = event.agentId || 'MAIN_AGENT';
-                if (!tokensByAgent[agentId]) {
-                    tokensByAgent[agentId] = { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheCreation: 0, calls: 0 };
-                }
-                tokensByAgent[agentId].inputTokens += event.inputTokens || 0;
-                tokensByAgent[agentId].outputTokens += event.outputTokens || 0;
-                tokensByAgent[agentId].cacheRead += event.cacheRead || 0;
-                tokensByAgent[agentId].cacheCreation += event.cacheCreation || 0;
-                tokensByAgent[agentId].calls += 1;
-            });
-
-            // Merge token data into subagent timelines
-            Object.entries(tokensByAgent).forEach(([agentId, tokens]) => {
-                if (subagentTimelines[agentId]) {
-                    subagentTimelines[agentId].inputTokens = tokens.inputTokens;
-                    subagentTimelines[agentId].outputTokens = tokens.outputTokens;
-                    subagentTimelines[agentId].cacheRead = tokens.cacheRead;
-                    subagentTimelines[agentId].llmCalls = tokens.calls;
-                }
-            });
-
-            // If no LLM events, estimate tokens from tool output sizes
-            // Rough estimation: 1 token ≈ 4 characters
-            if (llmEventData.length === 0) {
-                toolCallData.forEach(tc => {
-                    const agentId = tc.agentId;
-                    if (!tokensByAgent[agentId]) {
-                        tokensByAgent[agentId] = { inputTokens: 0, outputTokens: 0, estimated: true };
-                    }
-                    // Estimate output tokens from tool output size
-                    if (tc.outputSize) {
-                        tokensByAgent[agentId].outputTokens += Math.round(tc.outputSize / 4);
-                    }
-                    // Estimate input tokens from tool input
-                    const inputStr = JSON.stringify(tc.toolInput || {});
-                    tokensByAgent[agentId].inputTokens += Math.round(inputStr.length / 4);
-                });
-
-                // Merge estimates into subagent timelines
-                Object.entries(tokensByAgent).forEach(([agentId, tokens]) => {
-                    if (subagentTimelines[agentId]) {
-                        subagentTimelines[agentId].inputTokens = tokens.inputTokens;
-                        subagentTimelines[agentId].outputTokens = tokens.outputTokens;
-                        subagentTimelines[agentId].estimated = true;
-                    }
-                });
-            }
-
-            // Calculate totals
-            const totalInputTokens = Object.values(tokensByAgent).reduce((sum, t) => sum + t.inputTokens, 0);
-            const totalOutputTokens = Object.values(tokensByAgent).reduce((sum, t) => sum + t.outputTokens, 0);
-            const totalCacheRead = Object.values(tokensByAgent).reduce((sum, t) => sum + (t.cacheRead || 0), 0);
-            const isEstimated = llmEventData.length === 0;
-
-            // Group agents by type for summary
-            const agentsByType = {};
-            Object.entries(subagentTimelines).forEach(([agentId, data]) => {
-                const type = data.type || 'unknown';
-                if (!agentsByType[type]) agentsByType[type] = [];
-                agentsByType[type].push({ agentId, ...data });
-            });
-
-            // Create overview div
-            const overviewDiv = document.createElement('div');
-            overviewDiv.className = 'session-overview';
-            overviewDiv.style.cssText = 'margin-bottom: 30px; padding: 20px; background: linear-gradient(135deg, #f5f7fa 0%, #e4e8ec 100%); border-radius: 12px; border: 1px solid #ddd;';
-
-            // Summary stats
-            const subagentCount = Object.keys(subagentTimelines).length;
-            const completedSubagents = Object.values(subagentTimelines).filter(s => s.complete).length;
-            const mainAgentCalls = toolCallData.filter(d => d.agentId === 'MAIN_AGENT').length;
-            const subagentCalls = toolCallData.filter(d => d.agentId !== 'MAIN_AGENT').length;
-
-            // Cost estimation (using Claude Sonnet pricing as baseline)
-            // Input: $3/1M tokens, Output: $15/1M tokens, Cache read: $0.30/1M
-            const inputCost = (totalInputTokens / 1000000) * 3;
-            const outputCost = (totalOutputTokens / 1000000) * 15;
-            const cacheSavings = (totalCacheRead / 1000000) * (3 - 0.30); // savings vs regular input
-            const totalCost = inputCost + outputCost;
-
-            let html = `
-                <h3 style="margin: 0 0 15px 0; display: flex; align-items: center; gap: 10px;">
-                    <span style="font-size: 24px;">📊</span>
-                    Session Overview
-                    <span style="font-size: 14px; font-weight: normal; color: #666;">
-                        (${formatTime(totalDuration)} total)
-                    </span>
-                </h3>
-                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 12px; margin-bottom: 20px;">
-                    <div style="background: white; padding: 12px; border-radius: 8px; text-align: center;">
-                        <div style="font-size: 24px; font-weight: bold; color: #667eea;">${subagentCount}</div>
-                        <div style="font-size: 11px; color: #666;">Subagents</div>
-                    </div>
-                    <div style="background: white; padding: 12px; border-radius: 8px; text-align: center;">
-                        <div style="font-size: 24px; font-weight: bold; color: #43e97b;">${completedSubagents}</div>
-                        <div style="font-size: 11px; color: #666;">Completed</div>
-                    </div>
-                    <div style="background: white; padding: 12px; border-radius: 8px; text-align: center;">
-                        <div style="font-size: 24px; font-weight: bold; color: #4facfe;">${mainAgentCalls + subagentCalls}</div>
-                        <div style="font-size: 11px; color: #666;">Total Tool Calls</div>
-                    </div>
-                    <div style="background: white; padding: 12px; border-radius: 8px; text-align: center; border: 2px solid #667eea;">
-                        <div style="font-size: 24px; font-weight: bold; color: #667eea;">${formatTokens(totalInputTokens)}</div>
-                        <div style="font-size: 11px; color: #666;">Input Tokens${isEstimated ? '*' : ''}</div>
-                    </div>
-                    <div style="background: white; padding: 12px; border-radius: 8px; text-align: center; border: 2px solid #f093fb;">
-                        <div style="font-size: 24px; font-weight: bold; color: #f093fb;">${formatTokens(totalOutputTokens)}</div>
-                        <div style="font-size: 11px; color: #666;">Output Tokens${isEstimated ? '*' : ''}</div>
-                    </div>
-                    <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 12px; border-radius: 8px; text-align: center; color: white;">
-                        <div style="font-size: 24px; font-weight: bold;">$${totalCost.toFixed(2)}</div>
-                        <div style="font-size: 11px; opacity: 0.9;">Est. Cost${isEstimated ? '*' : ''}</div>
-                    </div>
-                </div>
-                ${isEstimated ? '<p style="font-size: 11px; color: #999; margin: -10px 0 15px 0;">* Token counts estimated from tool I/O. Run with updated callbacks for accurate tracking.</p>' : ''}
-            `;
-
-            // Subagent type breakdown with token consumption
-            if (Object.keys(agentsByType).length > 0) {
-                html += `<h4 style="margin: 20px 0 10px 0;">Token Consumption by Agent Type</h4>`;
-                html += `<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 12px;">`;
-                
-                const typeColors = {
-                    'code-library-analyzer': '#4facfe',
-                    'application-analyzer': '#43e97b',
-                    'architecture-documenter': '#f093fb',
-                    'external-service-analyzer': '#fa709a'
-                };
-
-                // Add MAIN_AGENT tokens
-                const mainAgentTokens = tokensByAgent['MAIN_AGENT'] || { inputTokens: 0, outputTokens: 0 };
-                const mainTotalTokens = mainAgentTokens.inputTokens + mainAgentTokens.outputTokens;
-                const mainCost = (mainAgentTokens.inputTokens / 1000000) * 3 + (mainAgentTokens.outputTokens / 1000000) * 15;
-                
-                html += `
-                    <div style="background: white; padding: 12px 15px; border-radius: 6px; border-left: 4px solid #667eea;">
-                        <div style="display: flex; justify-content: space-between; align-items: center;">
-                            <div style="font-weight: 600;">Lead Agent</div>
-                            <div style="font-size: 14px; font-weight: bold; color: #667eea;">$${mainCost.toFixed(2)}</div>
-                        </div>
-                        <div style="font-size: 12px; color: #666; margin-top: 4px;">
-                            ${formatTokens(mainAgentTokens.inputTokens)} in / ${formatTokens(mainAgentTokens.outputTokens)} out
-                        </div>
-                        <div style="margin-top: 6px; background: #f0f0f0; border-radius: 4px; height: 6px; overflow: hidden;">
-                            <div style="background: #667eea; height: 100%; width: ${totalInputTokens + totalOutputTokens > 0 ? (mainTotalTokens / (totalInputTokens + totalOutputTokens) * 100) : 0}%;"></div>
-                        </div>
-                    </div>
-                `;
-
-                Object.entries(agentsByType).forEach(([type, agents]) => {
-                    const color = typeColors[type] || '#667eea';
-                    const completed = agents.filter(a => a.complete).length;
-                    
-                    // Sum tokens for this type
-                    const typeInputTokens = agents.reduce((sum, a) => sum + (a.inputTokens || 0), 0);
-                    const typeOutputTokens = agents.reduce((sum, a) => sum + (a.outputTokens || 0), 0);
-                    const typeTotalTokens = typeInputTokens + typeOutputTokens;
-                    const typeCost = (typeInputTokens / 1000000) * 3 + (typeOutputTokens / 1000000) * 15;
-                    
-                    // Get token contribution from tokensByAgent for agents of this type
-                    let agentTypeTokens = { inputTokens: 0, outputTokens: 0 };
-                    agents.forEach(a => {
-                        const agentTokens = tokensByAgent[a.agentId];
-                        if (agentTokens) {
-                            agentTypeTokens.inputTokens += agentTokens.inputTokens || 0;
-                            agentTypeTokens.outputTokens += agentTokens.outputTokens || 0;
-                        }
-                    });
-                    const actualTypeCost = (agentTypeTokens.inputTokens / 1000000) * 3 + (agentTypeTokens.outputTokens / 1000000) * 15;
-                    const actualTotalTokens = agentTypeTokens.inputTokens + agentTypeTokens.outputTokens;
-                    
-                    html += `
-                        <div style="background: white; padding: 12px 15px; border-radius: 6px; border-left: 4px solid ${color};">
-                            <div style="display: flex; justify-content: space-between; align-items: center;">
-                                <div style="font-weight: 600;">${type}</div>
-                                <div style="font-size: 14px; font-weight: bold; color: ${color};">$${actualTypeCost.toFixed(2)}</div>
-                            </div>
-                            <div style="font-size: 12px; color: #666; margin-top: 4px;">
-                                ${agents.length} agents · ${formatTokens(agentTypeTokens.inputTokens)} in / ${formatTokens(agentTypeTokens.outputTokens)} out
-                            </div>
-                            <div style="margin-top: 6px; background: #f0f0f0; border-radius: 4px; height: 6px; overflow: hidden;">
-                                <div style="background: ${color}; height: 100%; width: ${totalInputTokens + totalOutputTokens > 0 ? (actualTotalTokens / (totalInputTokens + totalOutputTokens) * 100) : 0}%;"></div>
-                            </div>
-                        </div>
-                    `;
-                });
-                html += `</div>`;
-            }
-
-            // Per-agent token breakdown table
-            if (Object.keys(tokensByAgent).length > 0) {
-                const sortedAgents = Object.entries(tokensByAgent)
-                    .map(([id, t]) => ({ id, ...t, total: t.inputTokens + t.outputTokens, cost: (t.inputTokens / 1000000) * 3 + (t.outputTokens / 1000000) * 15 }))
-                    .sort((a, b) => b.total - a.total);
-                
-                const topAgents = sortedAgents.slice(0, 10);
-                const maxTokens = topAgents[0]?.total || 1;
-
-                html += `
-                    <details style="margin-top: 20px;">
-                        <summary style="cursor: pointer; font-weight: 600; padding: 10px 0;">
-                            📋 Per-Agent Token Breakdown (Top 10 by usage)
-                        </summary>
-                        <div style="background: white; border-radius: 8px; padding: 15px; margin-top: 10px;">
-                            <table style="width: 100%; border-collapse: collapse; font-size: 13px;">
-                                <thead>
-                                    <tr style="border-bottom: 2px solid #ddd;">
-                                        <th style="text-align: left; padding: 8px;">Agent</th>
-                                        <th style="text-align: right; padding: 8px;">Input</th>
-                                        <th style="text-align: right; padding: 8px;">Output</th>
-                                        <th style="text-align: right; padding: 8px;">Total</th>
-                                        <th style="text-align: right; padding: 8px;">Cost</th>
-                                        <th style="padding: 8px; width: 150px;"></th>
-                                    </tr>
-                                </thead>
-                                <tbody>
-                                    ${topAgents.map(agent => `
-                                        <tr style="border-bottom: 1px solid #eee;">
-                                            <td style="padding: 8px; font-weight: ${agent.id === 'MAIN_AGENT' ? 'bold' : 'normal'};">
-                                                ${agent.id === 'MAIN_AGENT' ? '👑 ' : ''}${agent.id.length > 30 ? agent.id.substring(0, 27) + '...' : agent.id}
-                                            </td>
-                                            <td style="text-align: right; padding: 8px; color: #667eea;">${formatTokens(agent.inputTokens)}</td>
-                                            <td style="text-align: right; padding: 8px; color: #f093fb;">${formatTokens(agent.outputTokens)}</td>
-                                            <td style="text-align: right; padding: 8px; font-weight: bold;">${formatTokens(agent.total)}</td>
-                                            <td style="text-align: right; padding: 8px; color: #4CAF50; font-weight: bold;">$${agent.cost.toFixed(3)}</td>
-                                            <td style="padding: 8px;">
-                                                <div style="background: #f0f0f0; border-radius: 4px; height: 8px; overflow: hidden;">
-                                                    <div style="background: linear-gradient(90deg, #667eea ${agent.inputTokens / agent.total * 100}%, #f093fb ${agent.inputTokens / agent.total * 100}%); height: 100%; width: ${agent.total / maxTokens * 100}%;"></div>
-                                                </div>
-                                            </td>
-                                        </tr>
-                                    `).join('')}
-                                </tbody>
-                            </table>
-                            ${isEstimated ? '<p style="font-size: 11px; color: #999; margin: 10px 0 0 0;">* Tokens estimated from tool I/O sizes</p>' : ''}
-                        </div>
-                    </details>
-                `;
-            }
-
-            // Layer-based orchestration info (if available)
-            const layerEvents = window.layerEventData || [];
-            const orchestrationEvts = window.orchestrationEvents || [];
-            
-            if (layerEvents.length > 0) {
-                const layerStarts = layerEvents.filter(e => e.event === 'layer_start');
-                const layerCompletes = layerEvents.filter(e => e.event === 'layer_complete');
-                
-                html += `
-                    <h4 style="margin: 25px 0 10px 0;">Parallel Layer Execution</h4>
-                    <div style="background: white; border-radius: 8px; padding: 15px; margin-bottom: 15px;">
-                        <p style="color: #666; margin: 0 0 15px 0;">
-                            Components analyzed in <strong>${layerStarts.length} dependency layers</strong> with parallel dispatch per layer.
-                        </p>
-                        <div style="display: flex; gap: 10px; flex-wrap: wrap;">
-                            ${layerStarts.map((layer, i) => {
-                                const complete = layerCompletes.find(c => c.layerIndex === layer.layerIndex);
-                                const success = complete?.successful || 0;
-                                const failed = complete?.failed || 0;
-                                const duration = complete?.durationSeconds?.toFixed(1) || '?';
-                                return `
-                                    <div style="background: #f5f5f5; padding: 12px; border-radius: 6px; min-width: 120px; border-left: 4px solid ${failed > 0 ? '#f44336' : '#4CAF50'};">
-                                        <div style="font-weight: bold; margin-bottom: 4px;">Layer ${layer.layerIndex}</div>
-                                        <div style="font-size: 12px; color: #666;">
-                                            ${layer.componentCount} components<br>
-                                            ${success} succeeded${failed > 0 ? `, ${failed} failed` : ''}<br>
-                                            ${duration}s
-                                        </div>
-                                    </div>
-                                `;
-                            }).join('')}
-                        </div>
-                    </div>
-                `;
-            }
-
-            // Orchestration timeline visualization
-            if (subagentCount > 0) {
-                html += `<h4 style="margin: 25px 0 10px 0;">Orchestration Timeline</h4>`;
-                html += `<div id="orchestrationTimeline" style="background: white; border-radius: 8px; padding: 15px; overflow-x: auto;"></div>`;
-            }
-
-            overviewDiv.innerHTML = html;
-            container.appendChild(overviewDiv);
-
-            // Draw orchestration timeline SVG
-            if (subagentCount > 0) {
-                const timelineDiv = document.getElementById('orchestrationTimeline');
-                const svgWidth = Math.max(800, timelineDiv.offsetWidth - 30);
-                const barHeight = 25;
-                const svgHeight = (subagentCount + 1) * (barHeight + 5) + 60;
-
-                const svg = d3.select('#orchestrationTimeline')
-                    .append('svg')
-                    .attr('width', svgWidth)
-                    .attr('height', svgHeight);
-
-                const margin = { left: 200, right: 20, top: 30, bottom: 30 };
-                const width = svgWidth - margin.left - margin.right;
-
-                const xScale = d3.scaleTime()
-                    .domain([globalMinTime, globalMaxTime])
-                    .range([0, width]);
-
-                const g = svg.append('g')
-                    .attr('transform', `translate(${margin.left}, ${margin.top})`);
-
-                // X axis
-                g.append('g')
-                    .attr('transform', `translate(0, ${svgHeight - margin.top - margin.bottom})`)
-                    .call(d3.axisBottom(xScale).ticks(8).tickFormat(d => {
-                        const secs = (d - globalMinTime) / 1000;
-                        return `+${formatTime(secs)}`;
-                    }));
-
-                // Draw MAIN_AGENT bar first
-                const mainAgentTools = toolCallData.filter(d => d.agentId === 'MAIN_AGENT');
-                if (mainAgentTools.length > 0) {
-                    const mainStart = d3.min(mainAgentTools, d => d.timestamp);
-                    const mainEnd = d3.max(mainAgentTools, d => d.completeTimestamp || d.timestamp);
-                    
-                    g.append('rect')
-                        .attr('x', xScale(mainStart))
-                        .attr('y', 0)
-                        .attr('width', Math.max(2, xScale(mainEnd) - xScale(mainStart)))
-                        .attr('height', barHeight)
-                        .attr('fill', '#667eea')
-                        .attr('rx', 4);
-                    
-                    g.append('text')
-                        .attr('x', -10)
-                        .attr('y', barHeight / 2 + 4)
-                        .attr('text-anchor', 'end')
-                        .attr('font-size', '12px')
-                        .attr('font-weight', 'bold')
-                        .text('LEAD AGENT');
-                }
-
-                // Draw subagent bars
-                const sortedSubagents = Object.entries(subagentTimelines)
-                    .sort((a, b) => (a[1].spawn || globalMinTime) - (b[1].spawn || globalMinTime));
-
-                sortedSubagents.forEach(([agentId, data], idx) => {
-                    const y = (idx + 1) * (barHeight + 5);
-                    const start = data.spawn || globalMinTime;
-                    const end = data.complete || globalMaxTime;
-                    const color = data.complete ? '#43e97b' : '#ffa500';
-                    
-                    // Bar
-                    g.append('rect')
-                        .attr('x', xScale(start))
-                        .attr('y', y)
-                        .attr('width', Math.max(2, xScale(end) - xScale(start)))
-                        .attr('height', barHeight)
-                        .attr('fill', color)
-                        .attr('opacity', 0.7)
-                        .attr('rx', 4)
-                        .style('cursor', 'pointer')
-                        .on('mouseover', function(event) {
-                            d3.select(this).attr('opacity', 1);
-                            const tooltip = document.getElementById('tooltip');
-                            tooltip.style.display = 'block';
-                            const dur = data.duration || ((end - start) / 1000);
-                            const agentTokens = tokensByAgent[agentId] || { inputTokens: 0, outputTokens: 0 };
-                            const agentCost = (agentTokens.inputTokens / 1000000) * 3 + (agentTokens.outputTokens / 1000000) * 15;
-                            tooltip.innerHTML = `
-                                <div class="tooltip-title">${agentId}</div>
-                                <div class="tooltip-row"><span class="tooltip-label">Type:</span><span>${data.type || 'unknown'}</span></div>
-                                <div class="tooltip-row"><span class="tooltip-label">Duration:</span><span>${formatTime(dur)}</span></div>
-                                <div class="tooltip-row"><span class="tooltip-label">Tool Calls:</span><span>${data.toolCalls || 'N/A'}</span></div>
-                                <div class="tooltip-row"><span class="tooltip-label">Status:</span><span>${data.complete ? '✓ Complete' : '⏳ In Progress'}</span></div>
-                                <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                                    <div class="tooltip-row"><span class="tooltip-label">Input Tokens:</span><span>${formatTokens(agentTokens.inputTokens)}${isEstimated ? '*' : ''}</span></div>
-                                    <div class="tooltip-row"><span class="tooltip-label">Output Tokens:</span><span>${formatTokens(agentTokens.outputTokens)}${isEstimated ? '*' : ''}</span></div>
-                                    <div class="tooltip-row"><span class="tooltip-label">Est. Cost:</span><span style="font-weight: bold; color: #4CAF50;">$${agentCost.toFixed(3)}</span></div>
-                                </div>
-                                ${data.description ? `<div style="margin-top: 8px; font-size: 11px; color: #ccc;">${data.description}</div>` : ''}
-                            `;
-                            tooltip.style.left = event.pageX + 10 + 'px';
-                            tooltip.style.top = event.pageY + 10 + 'px';
-                        })
-                        .on('mouseout', function() {
-                            d3.select(this).attr('opacity', 0.7);
-                            document.getElementById('tooltip').style.display = 'none';
-                        });
-
-                    // Spawn marker
-                    if (data.spawn) {
-                        g.append('polygon')
-                            .attr('points', '0,-6 8,0 0,6')
-                            .attr('transform', `translate(${xScale(data.spawn)}, ${y + barHeight/2})`)
-                            .attr('fill', '#4CAF50');
-                    }
-
-                    // Complete marker
-                    if (data.complete) {
-                        g.append('rect')
-                            .attr('x', xScale(data.complete) - 4)
-                            .attr('y', y + barHeight/2 - 4)
-                            .attr('width', 8)
-                            .attr('height', 8)
-                            .attr('fill', '#f44336');
-                    }
-
-                    // Label (truncated)
-                    const shortId = agentId.length > 25 ? agentId.substring(0, 22) + '...' : agentId;
-                    g.append('text')
-                        .attr('x', -10)
-                        .attr('y', y + barHeight / 2 + 4)
-                        .attr('text-anchor', 'end')
-                        .attr('font-size', '11px')
-                        .text(shortId);
-                });
-            }
-        }
-
-        // Render timeline
-        function renderTimeline() {
-            const container = document.getElementById('timelineContainer');
-            container.innerHTML = '';
-
-            if (!toolCallData || toolCallData.length === 0) {
-                container.innerHTML = `
-                    <div style="text-align: center; padding: 60px 20px; color: #666;">
-                        <h3 style="margin-bottom: 10px;">No tool call data</h3>
-                        <p>Please load a tool_calls.jsonl file first</p>
-                    </div>
-                `;
-                return;
-            }
-
-            // Render session overview first
-            renderSessionOverview(container);
-
-            // Group by agent
-            const byAgent = d3.group(toolCallData, d => d.agentId);
-            const agents = Array.from(byAgent.keys()).sort((a, b) => {
-                if (a === 'MAIN_AGENT') return -1;
-                if (b === 'MAIN_AGENT') return 1;
-                return a.localeCompare(b);
-            });
-
-            // Create filters - preserve current values
-            const filters = document.getElementById('timelineFilters');
-            const currentWeightFilter = document.getElementById('weightFilter')?.value || '0';
-
-            // Get currently selected tools (preserve state)
-            const currentSelectedTools = new Set();
-            const existingCheckboxes = document.querySelectorAll('.tool-type-checkbox');
-            const isFirstRender = existingCheckboxes.length === 0;
-
-            document.querySelectorAll('.tool-type-checkbox:checked').forEach(cb => {
-                currentSelectedTools.add(cb.value);
-            });
-
-            const uniqueTools = Array.from(new Set(toolCallData.map(d => d.toolName))).sort();
-
-            // Only default to all selected on first render, not when user has deselected all
-            const defaultSelected = isFirstRender && currentSelectedTools.size === 0;
-
-            filters.innerHTML = `
-                <div class="filter-group" style="flex-direction: column; align-items: flex-start;">
-                    <div style="display: flex; gap: 10px; margin-bottom: 8px; align-items: center;">
-                        <label style="font-weight: 600;">Tool Types:</label>
-                        <button id="selectAllTools" style="padding: 4px 8px; font-size: 12px; cursor: pointer; border: 1px solid #ddd; background: white; border-radius: 3px;">Select All</button>
-                        <button id="deselectAllTools" style="padding: 4px 8px; font-size: 12px; cursor: pointer; border: 1px solid #ddd; background: white; border-radius: 3px;">Deselect All</button>
-                    </div>
-                    <div style="display: flex; flex-wrap: wrap; gap: 10px; max-width: 800px;">
-                        ${uniqueTools.map(tool => `
-                            <label style="display: flex; align-items: center; gap: 4px; cursor: pointer; padding: 4px 8px; background: #f5f5f5; border-radius: 4px; font-size: 13px;">
-                                <input type="checkbox" class="tool-type-checkbox" value="${tool}"
-                                    ${defaultSelected || currentSelectedTools.has(tool) ? 'checked' : ''}>
-                                <span>${tool}</span>
-                            </label>
-                        `).join('')}
-                    </div>
-                </div>
-                <div class="filter-group">
-                    <label>Min Weight:</label>
-                    <select id="weightFilter">
-                        <option value="0">All</option>
-                        <option value="6">Heavy+ (6-10)</option>
-                        <option value="9">Critical (9-10)</option>
-                    </select>
-                </div>
-            `;
-
-            // Restore filter values
-            document.getElementById('weightFilter').value = currentWeightFilter;
-
-            // Attach event listeners
-            document.querySelectorAll('.tool-type-checkbox').forEach(cb => {
-                cb.addEventListener('change', renderTimeline);
-            });
-            document.getElementById('weightFilter').addEventListener('change', renderTimeline);
-
-            // Select/Deselect all buttons
-            document.getElementById('selectAllTools').addEventListener('click', () => {
-                document.querySelectorAll('.tool-type-checkbox').forEach(cb => cb.checked = true);
-                renderTimeline();
-            });
-            document.getElementById('deselectAllTools').addEventListener('click', () => {
-                document.querySelectorAll('.tool-type-checkbox').forEach(cb => cb.checked = false);
-                renderTimeline();
-            });
-
-            // Get selected tools
-            const selectedTools = new Set();
-            document.querySelectorAll('.tool-type-checkbox:checked').forEach(cb => {
-                selectedTools.add(cb.value);
-            });
-            const weightFilter = parseFloat(currentWeightFilter);
-
-            // Also include agents that only have text blocks or thinking blocks
-            const agentsWithTextBlocks = new Set(textBlockData.map(tb => tb.agentId));
-            const agentsWithThinkingBlocks = new Set(thinkingBlockData.map(tb => tb.agentId));
-            const allAgentsSet = new Set([...agents, ...agentsWithTextBlocks, ...agentsWithThinkingBlocks]);
-            const allAgents = Array.from(allAgentsSet).sort((a, b) => {
-                if (a === 'MAIN_AGENT') return -1;
-                if (b === 'MAIN_AGENT') return 1;
-                return a.localeCompare(b);
-            });
-
-            allAgents.forEach(agentId => {
-                let agentData = byAgent.get(agentId) ? Array.from(byAgent.get(agentId)) : [];
-
-                // Apply filters
-                // Filter by selected tools (if none selected, show nothing)
-                agentData = agentData.filter(d => selectedTools.has(d.toolName));
-
-                if (weightFilter > 0) {
-                    agentData = agentData.filter(d => d.weight >= weightFilter);
-                }
-
-                // Check if this agent has text blocks or thinking blocks
-                const agentTextBlocks = textBlockData.filter(tb => tb.agentId === agentId);
-                const agentThinkingBlocks = thinkingBlockData.filter(tb => tb.agentId === agentId);
-
-                // Skip if no tool calls, text blocks, or thinking blocks
-                if (agentData.length === 0 && agentTextBlocks.length === 0 && agentThinkingBlocks.length === 0) return;
-
-                const agentDiv = document.createElement('div');
-                agentDiv.className = 'agent-timeline';
-
-                // Calculate time range from tool calls, text blocks, and thinking blocks
-                const toolTimes = agentData.map(d => d.timestamp);
-                const textTimes = agentTextBlocks.map(tb => tb.timestamp);
-                const thinkingTimes = agentThinkingBlocks.map(tb => tb.timestamp);
-                const allTimes = [...toolTimes, ...textTimes, ...thinkingTimes];
-
-                const minTime = d3.min(allTimes);
-                const maxTime = d3.max(allTimes);
-                const duration = (maxTime - minTime) / 1000;
-
-                const weights = agentData.map(d => d.weight);
-                const avgWeight = weights.length > 0 ? d3.mean(weights) : 0;
-                const criticalCount = weights.filter(w => w > 8).length;
-
-                agentDiv.innerHTML = `
-                    <div class="agent-label">
-                        ${agentId}
-                        ${agentData.length > 0 ? `<span class="agent-badge">${agentData.length} calls</span>` : ''}
-                        ${agentTextBlocks.length > 0 ? `<span class="agent-badge" style="background: #e91e63">${agentTextBlocks.length} text blocks</span>` : ''}
-                        ${agentThinkingBlocks.length > 0 ? `<span class="agent-badge" style="background: #9C27B0">${agentThinkingBlocks.length} thinking blocks</span>` : ''}
-                        ${weights.length > 0 ? `<span class="agent-badge" style="background: ${avgWeight > 8 ? '#FF4500' : avgWeight > 6 ? '#FFA500' : '#667eea'}">
-                            Avg: ${avgWeight.toFixed(1)}
-                        </span>` : ''}
-                        ${criticalCount > 0 ? `<span class="agent-badge" style="background: #FF4500">⚠️ ${criticalCount} critical</span>` : ''}
-                    </div>
-                `;
-
-                const svg = d3.create('svg')
-                    .attr('width', '100%')
-                    .attr('height', 80)
-                    .style('overflow', 'visible');
-
-                const margin = { left: 0, right: 50, top: 20, bottom: 20 };
-                const width = container.offsetWidth - margin.left - margin.right;
-
-                const xScale = d3.scaleTime()
-                    .domain([minTime, maxTime])
-                    .range([margin.left, width]);
-
-                const xAxis = d3.axisBottom(xScale)
-                    .ticks(8)
-                    .tickFormat(d => {
-                        const seconds = (d - minTime) / 1000;
-                        return `+${formatTime(seconds)}`;
-                    });
-
-                svg.append('g')
-                    .attr('transform', `translate(0, 50)`)
-                    .call(xAxis);
-
-                svg.append('line')
-                    .attr('x1', margin.left)
-                    .attr('x2', width)
-                    .attr('y1', 30)
-                    .attr('y2', 30)
-                    .attr('stroke', '#ddd')
-                    .attr('stroke-width', 1);
-
-                // Draw text blocks as small vertical markers (draw before tool calls so they appear behind)
-                svg.selectAll('.text-block')
-                    .data(agentTextBlocks)
-                    .join('line')
-                    .attr('class', 'text-block-marker')
-                    .attr('x1', d => xScale(d.timestamp))
-                    .attr('x2', d => xScale(d.timestamp))
-                    .attr('y1', 5)
-                    .attr('y2', 55)
-                    .attr('stroke', '#e91e63')
-                    .attr('stroke-width', 2)
-                    .attr('opacity', 0.7)
-                    .on('mouseover', function(event, d) {
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">📝 Text Block</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Time:</span>
-                                <span>+${formatTime((d.timestamp - minTime) / 1000)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Length:</span>
-                                <span>${d.textLength} chars</span>
-                            </div>
-                            <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                                <div class="tooltip-label">Preview:</div>
-                                <div style="font-size: 11px; margin-top: 4px; max-width: 300px; word-break: break-word;">
-                                    ${d.text.substring(0, 150)}${d.text.length > 150 ? '...' : ''}
-                                </div>
-                            </div>
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', () => {
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-
-                // Draw thinking blocks as vertical markers with distinct styling
-                svg.selectAll('.thinking-block')
-                    .data(agentThinkingBlocks)
-                    .join('line')
-                    .attr('class', 'thinking-block-marker')
-                    .attr('x1', d => xScale(d.timestamp))
-                    .attr('x2', d => xScale(d.timestamp))
-                    .attr('y1', 5)
-                    .attr('y2', 55)
-                    .attr('stroke', '#9C27B0')
-                    .attr('stroke-width', 2)
-                    .attr('stroke-dasharray', '4,2')
-                    .attr('opacity', 0.7)
-                    .on('mouseover', function(event, d) {
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">💭 Thinking Block</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Time:</span>
-                                <span>+${formatTime((d.timestamp - minTime) / 1000)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Length:</span>
-                                <span>${d.thinkingLength} chars</span>
-                            </div>
-                            <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                                <div class="tooltip-label">Preview:</div>
-                                <div style="font-size: 11px; margin-top: 4px; max-width: 300px; word-break: break-word;">
-                                    ${d.thinking.substring(0, 150)}${d.thinking.length > 150 ? '...' : ''}
-                                </div>
-                            </div>
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', () => {
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-
-                // Draw completion lines (duration bars) for tool calls that have completed
-                svg.selectAll('.tool-duration')
-                    .data(agentData.filter(d => d.completeTimestamp))
-                    .join('line')
-                    .attr('class', 'tool-duration')
-                    .attr('x1', d => xScale(d.timestamp))
-                    .attr('x2', d => xScale(d.completeTimestamp))
-                    .attr('y1', 30)
-                    .attr('y2', 30)
-                    .attr('stroke', d => d.success === false ? '#ff4444' : '#4CAF50')
-                    .attr('stroke-width', 3)
-                    .attr('opacity', 0.6);
-
-                // Draw completion markers (end points)
-                svg.selectAll('.tool-complete')
-                    .data(agentData.filter(d => d.completeTimestamp))
-                    .join('rect')
-                    .attr('class', 'tool-complete-marker')
-                    .attr('x', d => xScale(d.completeTimestamp) - 3)
-                    .attr('y', 27)
-                    .attr('width', 6)
-                    .attr('height', 6)
-                    .attr('fill', d => d.success === false ? '#ff4444' : '#4CAF50')
-                    .attr('opacity', 0.9)
-                    .on('mouseover', function(event, d) {
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">✓ ${d.toolName} Complete</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Start:</span>
-                                <span>+${formatTime((d.timestamp - minTime) / 1000)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Complete:</span>
-                                <span>+${formatTime((d.completeTimestamp - minTime) / 1000)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Duration:</span>
-                                <span style="font-weight: bold; color: ${d.duration > 5 ? '#ff9800' : '#4CAF50'}">${formatTime(d.duration)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Status:</span>
-                                <span style="font-weight: bold; color: ${d.success === false ? '#ff4444' : '#4CAF50'}">
-                                    ${d.success === false ? '✗ Failed' : '✓ Success'}
-                                </span>
-                            </div>
-                            ${d.outputSize ? `
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Output Size:</span>
-                                <span>${(d.outputSize / 1024).toFixed(1)} KB</span>
-                            </div>
-                            ` : ''}
-                            ${d.error ? `
-                            <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                                <div class="tooltip-label">Error:</div>
-                                <div style="font-size: 11px; margin-top: 4px; color: #ff4444;">
-                                    ${d.error.substring(0, 100)}${d.error.length > 100 ? '...' : ''}
-                                </div>
-                            </div>
-                            ` : ''}
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', () => {
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-
-                // Draw tool calls (start points)
-                svg.selectAll('.tool-call')
-                    .data(agentData)
-                    .join('circle')
-                    .attr('class', 'tool-call-point')
-                    .attr('cx', d => xScale(d.timestamp))
-                    .attr('cy', 30)
-                    .attr('r', d => 3 + d.weight * 1.5)
-                    .attr('fill', d => toolColors(d.toolName))
-                    .attr('stroke', d => d.weightCategory.color)
-                    .attr('stroke-width', 2.5)
-                    .attr('opacity', 0.8)
-                    .on('mouseover', function(event, d) {
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">${d.toolName}</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Started:</span>
-                                <span>+${formatTime((d.timestamp - minTime) / 1000)}</span>
-                            </div>
-                            ${d.duration !== null ? `
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Duration:</span>
-                                <span style="font-weight: bold; color: ${d.duration > 5 ? '#ff9800' : '#4CAF50'}">${formatTime(d.duration)}</span>
-                            </div>
-                            ` : `
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Status:</span>
-                                <span style="color: #ff9800">⏳ No completion event</span>
-                            </div>
-                            `}
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Context Weight:</span>
-                                <span class="weight-badge weight-${d.weightCategory.class}">
-                                    ${d.weight.toFixed(1)} (${d.weightCategory.label})
-                                </span>
-                            </div>
-                            ${d.outputSize ? `
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Output Size:</span>
-                                <span>${(d.outputSize / 1024).toFixed(1)} KB</span>
-                            </div>
-                            ` : ''}
-                            ${d.success === false ? `
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Status:</span>
-                                <span style="font-weight: bold; color: #ff4444">✗ Failed</span>
-                            </div>
-                            ` : ''}
-                            ${d.toolName === 'Bash' && d.toolInput.command ? `
-                            <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                                <div class="tooltip-label">Command:</div>
-                                <code style="font-size: 11px; display: block; margin-top: 4px; word-break: break-all;">
-                                    ${d.toolInput.command.substring(0, 100)}${d.toolInput.command.length > 100 ? '...' : ''}
-                                </code>
-                            </div>
-                            ` : ''}
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', () => {
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-
-                agentDiv.appendChild(svg.node());
-                container.appendChild(agentDiv);
-            });
-
-            // Add legend
-            const legendDiv = document.createElement('div');
-            legendDiv.className = 'legend';
-            legendDiv.innerHTML = '<strong>Tool Types:</strong>';
-
-            const uniqueTools2 = Array.from(new Set(toolCallData.map(d => d.toolName))).sort();
-            uniqueTools2.forEach(tool => {
-                const item = document.createElement('div');
-                item.className = 'legend-item';
-                item.innerHTML = `
-                    <div class="legend-color" style="background: ${toolColors(tool)}; border: 2px solid ${toolColors(tool)}"></div>
-                    <span>${tool}</span>
-                `;
-                legendDiv.appendChild(item);
-            });
-
-            // Add text block marker to legend
-            if (textBlockData.length > 0) {
-                const textBlockItem = document.createElement('div');
-                textBlockItem.className = 'legend-item';
-                textBlockItem.style.display = 'flex';
-                textBlockItem.style.alignItems = 'center';
-                textBlockItem.innerHTML = `
-                    <svg width="20" height="20" style="margin-right: 8px;">
-                        <line x1="10" x2="10" y1="3" y2="17" stroke="#e91e63" stroke-width="2" opacity="0.7"/>
-                    </svg>
-                    <span>Text Block</span>
-                `;
-                legendDiv.appendChild(textBlockItem);
-            }
-
-            if (thinkingBlockData.length > 0) {
-                const thinkingBlockItem = document.createElement('div');
-                thinkingBlockItem.className = 'legend-item';
-                thinkingBlockItem.style.display = 'flex';
-                thinkingBlockItem.style.alignItems = 'center';
-                thinkingBlockItem.innerHTML = `
-                    <svg width="20" height="20" style="margin-right: 8px;">
-                        <line x1="10" x2="10" y1="3" y2="17" stroke="#9C27B0" stroke-width="2" stroke-dasharray="4,2" opacity="0.7"/>
-                    </svg>
-                    <span>Thinking Block</span>
-                `;
-                legendDiv.appendChild(thinkingBlockItem);
-            }
-
-            legendDiv.innerHTML += '<div style="width: 100%; margin: 10px 0;"></div><strong>Context Weight:</strong>';
-
-            [
-                { label: 'Negligible (0-2)', color: '#90EE90' },
-                { label: 'Moderate (3-5)', color: '#FFD700' },
-                { label: 'Heavy (6-8)', color: '#FFA500' },
-                { label: 'Critical (9-10)', color: '#FF4500' }
-            ].forEach(cat => {
-                const item = document.createElement('div');
-                item.className = 'legend-item';
-                item.innerHTML = `
-                    <div class="legend-color" style="border-color: ${cat.color}; background: transparent;"></div>
-                    <span>${cat.label}</span>
-                `;
-                legendDiv.appendChild(item);
-            });
-
-            container.appendChild(legendDiv);
-        }
-
-        // Helper function to format seconds as HH:MM:SS
-        function formatTime(seconds) {
-            const hours = Math.floor(seconds / 3600);
-            const mins = Math.floor((seconds % 3600) / 60);
-            const secs = Math.floor(seconds % 60);
-            return `${hours}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
-        }
-
-        // Helper function to format token counts (e.g., 1500 -> "1.5K", 1500000 -> "1.50M")
-        function formatTokens(n) {
-            if (n >= 1000000) return (n / 1000000).toFixed(2) + 'M';
-            if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
-            return n.toString();
-        }
-
-        // Render lifespan
-        function renderLifespan() {
-            const svg = d3.select('#lifespanChart');
-            svg.selectAll('*').remove();
-
-            // Create filters
-            const filters = document.getElementById('lifespanFilters');
-
-            // Get currently selected tools (preserve state)
-            const currentSelectedTools = new Set();
-            const existingCheckboxes = document.querySelectorAll('.lifespan-tool-checkbox');
-            const isFirstRender = existingCheckboxes.length === 0;
-
-            document.querySelectorAll('.lifespan-tool-checkbox:checked').forEach(cb => {
-                currentSelectedTools.add(cb.value);
-            });
-
-            const uniqueTools = Array.from(new Set(toolCallData.map(d => d.toolName))).sort();
-
-            // Only default to all selected on first render, not when user has deselected all
-            const defaultSelected = isFirstRender && currentSelectedTools.size === 0;
-
-            filters.innerHTML = `
-                <div class="filter-group" style="flex-direction: column; align-items: flex-start;">
-                    <div style="display: flex; gap: 10px; margin-bottom: 8px; align-items: center;">
-                        <label style="font-weight: 600;">Tool Types:</label>
-                        <button id="lifespanSelectAllTools" style="padding: 4px 8px; font-size: 12px; cursor: pointer; border: 1px solid #ddd; background: white; border-radius: 3px;">Select All</button>
-                        <button id="lifespanDeselectAllTools" style="padding: 4px 8px; font-size: 12px; cursor: pointer; border: 1px solid #ddd; background: white; border-radius: 3px;">Deselect All</button>
-                    </div>
-                    <div style="display: flex; flex-wrap: wrap; gap: 10px; max-width: 800px;">
-                        ${uniqueTools.map(tool => `
-                            <label style="display: flex; align-items: center; gap: 4px; cursor: pointer; padding: 4px 8px; background: #f5f5f5; border-radius: 4px; font-size: 13px;">
-                                <input type="checkbox" class="lifespan-tool-checkbox" value="${tool}"
-                                    ${defaultSelected || currentSelectedTools.has(tool) ? 'checked' : ''}>
-                                <span>${tool}</span>
-                            </label>
-                        `).join('')}
-                    </div>
-                </div>
-            `;
-
-            // Attach event listeners
-            document.querySelectorAll('.lifespan-tool-checkbox').forEach(cb => {
-                cb.addEventListener('change', renderLifespan);
-            });
-
-            // Select/Deselect all buttons
-            document.getElementById('lifespanSelectAllTools').addEventListener('click', () => {
-                document.querySelectorAll('.lifespan-tool-checkbox').forEach(cb => cb.checked = true);
-                renderLifespan();
-            });
-            document.getElementById('lifespanDeselectAllTools').addEventListener('click', () => {
-                document.querySelectorAll('.lifespan-tool-checkbox').forEach(cb => cb.checked = false);
-                renderLifespan();
-            });
-
-            // Get selected tools
-            const selectedTools = new Set();
-            document.querySelectorAll('.lifespan-tool-checkbox:checked').forEach(cb => {
-                selectedTools.add(cb.value);
-            });
-
-            const agents = Object.keys(agentLifespans).sort((a, b) => {
-                if (a === 'MAIN_AGENT') return -1;
-                if (b === 'MAIN_AGENT') return 1;
-                return a.localeCompare(b);
-            });
-
-            const allStarts = Object.values(agentLifespans).map(d => d.start);
-            const allEnds = Object.values(agentLifespans).map(d => d.end);
-            const minTime = d3.min(allStarts);
-            const maxTime = d3.max(allEnds);
-
-            const margin = { top: 40, right: 50, bottom: 50, left: 250 };
-            const width = 1400;
-            const height = agents.length * 60 + margin.top + margin.bottom;
-
-            svg.attr('width', width).attr('height', height);
-
-            const g = svg.append('g')
-                .attr('transform', `translate(${margin.left}, ${margin.top})`);
-
-            const xScale = d3.scaleTime()
-                .domain([minTime, maxTime])
-                .range([0, width - margin.left - margin.right]);
-
-            const yScale = d3.scaleBand()
-                .domain(agents)
-                .range([0, height - margin.top - margin.bottom])
-                .padding(0.3);
-
-            // X axis
-            const xAxisGroup = g.append('g')
-                .attr('transform', `translate(0, ${height - margin.top - margin.bottom})`)
-                .call(d3.axisBottom(xScale)
-                    .ticks(10)
-                    .tickFormat(d => {
-                        const seconds = (d - minTime) / 1000;
-                        return formatTime(seconds);
-                    }));
-
-            xAxisGroup.selectAll('text')
-                .style('font-size', '12px');
-
-            // Add axis label
-            xAxisGroup.append('text')
-                .attr('x', (width - margin.left - margin.right) / 2)
-                .attr('y', 40)
-                .attr('fill', '#666')
-                .attr('text-anchor', 'middle')
-                .attr('font-size', '13px')
-                .attr('font-weight', 'bold')
-                .text('Elapsed Time (HH:MM:SS)');
-
-            // Y axis
-            g.append('g')
-                .call(d3.axisLeft(yScale))
-                .selectAll('text')
-                .style('font-size', '13px')
-                .style('font-weight', d => d === 'MAIN_AGENT' ? 'bold' : 'normal');
-
-            // Bars
-            agents.forEach(agent => {
-                const data = agentLifespans[agent];
-                const duration = (data.end - data.start) / 1000;
-
-                g.append('rect')
-                    .attr('x', xScale(data.start))
-                    .attr('y', yScale(agent))
-                    .attr('width', xScale(data.end) - xScale(data.start))
-                    .attr('height', yScale.bandwidth())
-                    .attr('fill', agent === 'MAIN_AGENT' ? '#4169E1' : '#667eea')
-                    .attr('opacity', agent === 'MAIN_AGENT' ? 0.8 : 0.6)
-                    .attr('stroke', agent === 'MAIN_AGENT' ? 'darkblue' : '#333')
-                    .attr('stroke-width', agent === 'MAIN_AGENT' ? 2 : 1);
-
-                // Start marker
-                g.append('polygon')
-                    .attr('points', '0,-8 10,0 0,8')
-                    .attr('transform', `translate(${xScale(data.start)}, ${yScale(agent) + yScale.bandwidth() / 2})`)
-                    .attr('fill', 'green')
-                    .attr('stroke', 'darkgreen')
-                    .attr('stroke-width', 1);
-
-                // End marker
-                g.append('rect')
-                    .attr('x', xScale(data.end) - 5)
-                    .attr('y', yScale(agent) + yScale.bandwidth() / 2 - 5)
-                    .attr('width', 10)
-                    .attr('height', 10)
-                    .attr('fill', 'red')
-                    .attr('stroke', 'darkred')
-                    .attr('stroke-width', 1);
-
-                // Duration label
-                g.append('text')
-                    .attr('x', xScale(data.start) + (xScale(data.end) - xScale(data.start)) / 2)
-                    .attr('y', yScale(agent) + yScale.bandwidth() / 2)
-                    .attr('text-anchor', 'middle')
-                    .attr('dominant-baseline', 'middle')
-                    .attr('font-size', '12px')
-                    .attr('font-weight', 'bold')
-                    .attr('fill', '#333')
-                    .text(formatTime(duration));
-
-                // Add tool usage markers for this agent (with filter)
-                const agentTools = toolCallData.filter(tc =>
-                    tc.agentId === agent && selectedTools.has(tc.toolName)
-                );
-                g.selectAll(`.tool-marker-${agent.replace(/[^a-zA-Z0-9]/g, '_')}`)
-                    .data(agentTools)
-                    .join('circle')
-                    .attr('class', `tool-marker-${agent.replace(/[^a-zA-Z0-9]/g, '_')}`)
-                    .attr('cx', d => xScale(d.timestamp))
-                    .attr('cy', yScale(agent) + yScale.bandwidth() / 2)
-                    .attr('r', 4)
-                    .attr('fill', d => toolColors(d.toolName))
-                    .attr('stroke', d => d.weightCategory.color)
-                    .attr('stroke-width', 1.5)
-                    .attr('opacity', 0.9)
-                    .style('cursor', 'pointer')
-                    .on('mouseover', function(event, d) {
-                        d3.select(this).attr('r', 6).attr('opacity', 1);
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">${d.toolName}</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Agent:</span>
-                                <span>${agent}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Elapsed:</span>
-                                <span>${formatTime((d.timestamp - minTime) / 1000)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Weight:</span>
-                                <span class="weight-badge weight-${d.weightCategory.class}">
-                                    ${d.weight.toFixed(1)}
-                                </span>
-                            </div>
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', function() {
-                        d3.select(this).attr('r', 4).attr('opacity', 0.9);
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-
-                // Add text block markers for this agent
-                const agentTextBlocks = textBlockData.filter(tb => tb.agentId === agent);
-                g.selectAll(`.text-marker-${agent.replace(/[^a-zA-Z0-9]/g, '_')}`)
-                    .data(agentTextBlocks)
-                    .join('line')
-                    .attr('class', `text-marker-${agent.replace(/[^a-zA-Z0-9]/g, '_')}`)
-                    .attr('x1', d => xScale(d.timestamp))
-                    .attr('x2', d => xScale(d.timestamp))
-                    .attr('y1', yScale(agent))
-                    .attr('y2', yScale(agent) + yScale.bandwidth())
-                    .attr('stroke', '#e91e63')
-                    .attr('stroke-width', 2)
-                    .attr('opacity', 0.6)
-                    .style('cursor', 'pointer')
-                    .on('mouseover', function(event, d) {
-                        d3.select(this).attr('opacity', 1).attr('stroke-width', 3);
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">📝 Text Block</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Agent:</span>
-                                <span>${agent}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Elapsed:</span>
-                                <span>${formatTime((d.timestamp - minTime) / 1000)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Length:</span>
-                                <span>${d.textLength} chars</span>
-                            </div>
-                            <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                                <div class="tooltip-label">Preview:</div>
-                                <div style="font-size: 11px; margin-top: 4px; max-width: 300px; word-break: break-word;">
-                                    ${d.text.substring(0, 100)}${d.text.length > 100 ? '...' : ''}
-                                </div>
-                            </div>
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', function() {
-                        d3.select(this).attr('opacity', 0.6).attr('stroke-width', 2);
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-
-                // Add thinking block markers for this agent
-                const agentThinkingBlocks = thinkingBlockData.filter(tb => tb.agentId === agent);
-                g.selectAll(`.thinking-marker-${agent.replace(/[^a-zA-Z0-9]/g, '_')}`)
-                    .data(agentThinkingBlocks)
-                    .join('line')
-                    .attr('class', `thinking-marker-${agent.replace(/[^a-zA-Z0-9]/g, '_')}`)
-                    .attr('x1', d => xScale(d.timestamp))
-                    .attr('x2', d => xScale(d.timestamp))
-                    .attr('y1', yScale(agent))
-                    .attr('y2', yScale(agent) + yScale.bandwidth())
-                    .attr('stroke', '#9C27B0')
-                    .attr('stroke-width', 2)
-                    .attr('stroke-dasharray', '4,2')
-                    .attr('opacity', 0.6)
-                    .style('cursor', 'pointer')
-                    .on('mouseover', function(event, d) {
-                        d3.select(this).attr('opacity', 1).attr('stroke-width', 3);
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">💭 Thinking Block</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Agent:</span>
-                                <span>${agent}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Elapsed:</span>
-                                <span>${formatTime((d.timestamp - minTime) / 1000)}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Length:</span>
-                                <span>${d.thinkingLength} chars</span>
-                            </div>
-                            <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                                <div class="tooltip-label">Preview:</div>
-                                <div style="font-size: 11px; margin-top: 4px; max-width: 300px; word-break: break-word;">
-                                    ${d.thinking.substring(0, 100)}${d.thinking.length > 100 ? '...' : ''}
-                                </div>
-                            </div>
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', function() {
-                        d3.select(this).attr('opacity', 0.6).attr('stroke-width', 2);
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-            });
-
-            // Title
-            svg.append('text')
-                .attr('x', width / 2)
-                .attr('y', 20)
-                .attr('text-anchor', 'middle')
-                .attr('font-size', '18px')
-                .attr('font-weight', 'bold')
-                .text('Agent Lifespan Timeline with Tool Usage Patterns');
-
-            // Legend
-            const legendX = width - 200;
-            const legendY = 30;
-            const legendG = svg.append('g')
-                .attr('transform', `translate(${legendX}, ${legendY})`);
-
-            // Legend background
-            legendG.append('rect')
-                .attr('x', -10)
-                .attr('y', -10)
-                .attr('width', 180)
-                .attr('height', 125)
-                .attr('fill', 'white')
-                .attr('stroke', '#ddd')
-                .attr('stroke-width', 1)
-                .attr('rx', 5);
-
-            // Legend title
-            legendG.append('text')
-                .attr('x', 0)
-                .attr('y', 5)
-                .attr('font-size', '12px')
-                .attr('font-weight', 'bold')
-                .text('Legend');
-
-            // Tool usage marker
-            legendG.append('circle')
-                .attr('cx', 5)
-                .attr('cy', 25)
-                .attr('r', 4)
-                .attr('fill', '#667eea')
-                .attr('stroke', '#333')
-                .attr('stroke-width', 1.5);
-            legendG.append('text')
-                .attr('x', 15)
-                .attr('y', 28)
-                .attr('font-size', '11px')
-                .text('Tool Call');
-
-            // LLM Response marker
-            legendG.append('line')
-                .attr('x1', 5)
-                .attr('x2', 5)
-                .attr('y1', 38)
-                .attr('y2', 50)
-                .attr('stroke', '#e91e63')
-                .attr('stroke-width', 2)
-                .attr('opacity', 0.6);
-            legendG.append('text')
-                .attr('x', 15)
-                .attr('y', 47)
-                .attr('font-size', '11px')
-                .text('LLM Response');
-
-            // Extended thinking marker (if applicable)
-            legendG.append('line')
-                .attr('x1', 5)
-                .attr('x2', 5)
-                .attr('y1', 56)
-                .attr('y2', 68)
-                .attr('stroke', '#9C27B0')
-                .attr('stroke-width', 2)
-                .attr('stroke-dasharray', '4,2')
-                .attr('opacity', 0.6);
-            legendG.append('text')
-                .attr('x', 15)
-                .attr('y', 65)
-                .attr('font-size', '11px')
-                .text('Extended Thinking');
-
-            // Subagent spawn marker
-            legendG.append('polygon')
-                .attr('points', '0,-4 8,0 0,4')
-                .attr('transform', `translate(5, 80)`)
-                .attr('fill', 'green')
-                .attr('stroke', 'darkgreen')
-                .attr('stroke-width', 1);
-            legendG.append('text')
-                .attr('x', 15)
-                .attr('y', 83)
-                .attr('font-size', '11px')
-                .text('Subagent Spawn');
-
-            // End marker
-            legendG.append('rect')
-                .attr('x', 1)
-                .attr('y', 91)
-                .attr('width', 8)
-                .attr('height', 8)
-                .attr('fill', 'red')
-                .attr('stroke', 'darkred')
-                .attr('stroke-width', 1);
-            legendG.append('text')
-                .attr('x', 15)
-                .attr('y', 100)
-                .attr('font-size', '11px')
-                .text('Subagent Complete');
-
-            // Layer boundary marker (for parallel execution)
-            legendG.append('line')
-                .attr('x1', 0)
-                .attr('x2', 10)
-                .attr('y1', 115)
-                .attr('y2', 115)
-                .attr('stroke', '#FF9800')
-                .attr('stroke-width', 2)
-                .attr('stroke-dasharray', '5,3');
-            legendG.append('text')
-                .attr('x', 15)
-                .attr('y', 118)
-                .attr('font-size', '11px')
-                .text('Layer Boundary');
-        }
-
-        // Render analysis
-        function renderAnalysis() {
-            const container = document.getElementById('analysisContainer');
-
-            const byAgent = d3.group(toolCallData, d => d.agentId);
-            const agents = Array.from(byAgent.keys()).sort((a, b) => {
-                if (a === 'MAIN_AGENT') return -1;
-                if (b === 'MAIN_AGENT') return 1;
-                return a.localeCompare(b);
-            });
-
-            let html = '<h2 style="margin-bottom: 20px;">Context Weight Analysis by Agent</h2>';
-
-            agents.forEach(agent => {
-                const data = Array.from(byAgent.get(agent));
-                const weights = data.map(d => d.weight);
-                const avgWeight = d3.mean(weights);
-                const maxWeight = d3.max(weights);
-                const critical = weights.filter(w => w > 8).length;
-                const heavy = weights.filter(w => w > 6 && w <= 8).length;
-                const moderate = weights.filter(w => w >= 3 && w <= 6).length;
-                const negligible = weights.filter(w => w < 3).length;
-
-                // Group by tool name and calculate stats
-                const toolBreakdown = d3.rollup(
-                    data,
-                    v => ({
-                        count: v.length,
-                        avgWeight: d3.mean(v, d => d.weight),
-                        totalOutputSize: d3.sum(v, d => d.outputSize || 0),
-                        criticalCount: v.filter(d => d.weight > 8).length
-                    }),
-                    d => d.toolName
-                );
-
-                // Sort tools by count descending
-                const sortedTools = Array.from(toolBreakdown.entries())
-                    .sort((a, b) => b[1].count - a[1].count);
-
-                html += `
-                    <div style="margin-bottom: 30px; padding: 20px; background: #f9f9f9; border-radius: 8px; border-left: 4px solid ${avgWeight > 8 ? '#FF4500' : avgWeight > 6 ? '#FFA500' : '#667eea'}">
-                        <h3 style="margin-bottom: 15px;">${agent}</h3>
-                        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 15px; margin-bottom: 15px;">
-                            <div>
-                                <div style="font-size: 12px; color: #666;">Total Calls</div>
-                                <div style="font-size: 24px; font-weight: bold;">${data.length}</div>
-                            </div>
-                            <div>
-                                <div style="font-size: 12px; color: #666;">Avg Weight</div>
-                                <div style="font-size: 24px; font-weight: bold; color: ${avgWeight > 8 ? '#FF4500' : avgWeight > 6 ? '#FFA500' : '#667eea'}">${avgWeight.toFixed(2)}</div>
-                            </div>
-                            <div>
-                                <div style="font-size: 12px; color: #666;">Max Weight</div>
-                                <div style="font-size: 24px; font-weight: bold; color: ${maxWeight > 8 ? '#FF4500' : '#FFA500'}">${maxWeight.toFixed(2)}</div>
-                            </div>
-                        </div>
-                        <div style="margin-top: 15px;">
-                            <strong>Risk Distribution:</strong>
-                            <div style="display: flex; gap: 10px; margin-top: 10px; flex-wrap: wrap;">
-                                ${critical > 0 ? `<span class="weight-badge weight-critical">Critical: ${critical}</span>` : ''}
-                                ${heavy > 0 ? `<span class="weight-badge weight-heavy">Heavy: ${heavy}</span>` : ''}
-                                ${moderate > 0 ? `<span class="weight-badge weight-moderate">Moderate: ${moderate}</span>` : ''}
-                                ${negligible > 0 ? `<span class="weight-badge weight-negligible">Negligible: ${negligible}</span>` : ''}
-                            </div>
-                        </div>
-
-                        <div style="margin-top: 20px;">
-                            <strong>Tool Usage Breakdown:</strong>
-                            <div style="margin-top: 10px; background: white; border-radius: 6px; overflow: hidden;">
-                                <table style="width: 100%; border-collapse: collapse;">
-                                    <thead style="background: #f0f0f0;">
-                                        <tr>
-                                            <th style="padding: 10px; text-align: left; border-bottom: 2px solid #ddd;">Tool</th>
-                                            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #ddd;">Count</th>
-                                            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #ddd;">% of Agent</th>
-                                            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #ddd;">Avg Weight</th>
-                                            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #ddd;">Output Size</th>
-                                            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #ddd;">Critical</th>
-                                        </tr>
-                                    </thead>
-                                    <tbody>
-                                        ${sortedTools.map(([tool, stats]) => {
-                                            const percentage = (stats.count / data.length * 100).toFixed(1);
-                                            const weightColor = stats.avgWeight > 8 ? '#FF4500' :
-                                                              stats.avgWeight > 6 ? '#FFA500' :
-                                                              stats.avgWeight > 3 ? '#FFD700' : '#90EE90';
-                                            return `
-                                                <tr style="border-bottom: 1px solid #eee;">
-                                                    <td style="padding: 10px;">
-                                                        <div style="display: flex; align-items: center; gap: 8px;">
-                                                            <div style="width: 12px; height: 12px; border-radius: 50%; background: ${toolColors(tool)}; border: 1px solid #333;"></div>
-                                                            <strong>${tool}</strong>
-                                                        </div>
-                                                    </td>
-                                                    <td style="padding: 10px; text-align: center; font-weight: bold;">${stats.count}</td>
-                                                    <td style="padding: 10px; text-align: center;">${percentage}%</td>
-                                                    <td style="padding: 10px; text-align: center;">
-                                                        <span style="background: ${weightColor}; color: ${stats.avgWeight > 6 ? 'white' : '#333'}; padding: 2px 8px; border-radius: 12px; font-size: 12px; font-weight: bold;">
-                                                            ${stats.avgWeight.toFixed(1)}
-                                                        </span>
-                                                    </td>
-                                                    <td style="padding: 10px; text-align: center;">${stats.totalOutputSize > 0 ? (stats.totalOutputSize / 1024).toFixed(1) + ' KB' : 'N/A'}</td>
-                                                    <td style="padding: 10px; text-align: center;">
-                                                        ${stats.criticalCount > 0 ?
-                                                            `<span class="weight-badge weight-critical">${stats.criticalCount}</span>` :
-                                                            '<span style="color: #999;">0</span>'}
-                                                    </td>
-                                                </tr>
-                                            `;
-                                        }).join('')}
-                                    </tbody>
-                                </table>
-                            </div>
-                        </div>
-
-                        ${critical > 0 ? `
-                        <div style="margin-top: 15px; padding: 10px; background: #fff3cd; border-left: 3px solid #ffc107; border-radius: 4px;">
-                            <strong>⚠️ Warning:</strong> This agent has ${critical} critical tool calls (weight > 8) that may cause significant context bloat.
-                        </div>
-                        ` : ''}
-                    </div>
-                `;
-            });
-
-            container.innerHTML = html;
-        }
-
-        // Extract resources from tool call
-        function extractResources(toolCall) {
-            const resources = [];
-            const input = toolCall.toolInput;
-
-            if (toolCall.toolName === 'Read' || toolCall.toolName === 'Write' || toolCall.toolName === 'Edit') {
-                if (input.file_path) {
-                    resources.push({
-                        type: 'file',
-                        value: input.file_path,
-                        directory: input.file_path.split('/').slice(0, -1).join('/')
-                    });
-                }
-            } else if (toolCall.toolName === 'Bash') {
-                // Extract file paths from bash commands
-                if (input.command) {
-                    const cmd = input.command;
-                    // Match file paths in commands
-                    const pathMatches = cmd.match(/(?:^|\s)([\w\-\.\/]+\/[\w\-\.\/]+)/g);
-                    if (pathMatches) {
-                        pathMatches.forEach(match => {
-                            const path = match.trim();
-                            resources.push({
-                                type: 'file',
-                                value: path,
-                                directory: path.split('/').slice(0, -1).join('/')
-                            });
-                        });
-                    }
-                }
-            } else if (toolCall.toolName === 'Glob' || toolCall.toolName === 'Grep') {
-                if (input.pattern) {
-                    resources.push({
-                        type: 'pattern',
-                        value: input.pattern,
-                        directory: input.path || ''
-                    });
-                }
-                if (input.path) {
-                    resources.push({
-                        type: 'directory',
-                        value: input.path,
-                        directory: input.path
-                    });
-                }
-            }
-
-            return resources;
-        }
-
-        // Store zoom state for clustering view
-        let clusteringZoomTransform = null;
-
-        // Render clustering
-        function renderClustering() {
-            const svg = d3.select('#clusterGraph');
-
-            // Save current zoom transform before clearing
-            const existingG = svg.select('g');
-            if (!existingG.empty()) {
-                const transform = existingG.attr('transform');
-                if (transform) {
-                    clusteringZoomTransform = transform;
-                }
-            }
-
-            svg.selectAll('*').remove();
-
-            const clusterBy = document.getElementById('clusterBy').value;
-            const minLinks = parseInt(document.getElementById('minLinks').value);
-
-            // Collect unique agents, directories, and files for filter dropdowns
-            const agents = new Set();
-            const directories = new Set();
-            const files = new Set();
-
-            toolCallData.forEach(call => {
-                agents.add(call.agentId);
-                const resources = extractResources(call);
-                resources.forEach(res => {
-                    if (res.directory) directories.add(res.directory);
-                    if (res.type === 'file' || res.type === 'glob') {
-                        files.add(res.value);
-                    }
-                });
-            });
-
-            // Populate filter dropdowns (preserve current selections)
-            const filterAgent = document.getElementById('filterAgent');
-            const filterDirectory = document.getElementById('filterDirectory');
-            const filterFile = document.getElementById('filterFile');
-
-            const currentAgents = Array.from(filterAgent.selectedOptions).map(o => o.value);
-            const currentDirs = Array.from(filterDirectory.selectedOptions).map(o => o.value);
-            const currentFiles = Array.from(filterFile.selectedOptions).map(o => o.value);
-
-            // Update agent filter
-            filterAgent.innerHTML = '<option value="">All Agents</option>' +
-                Array.from(agents).sort().map(a =>
-                    `<option value="${a}" ${currentAgents.includes(a) ? 'selected' : ''}>${a}</option>`
-                ).join('');
-
-            // Update directory filter
-            filterDirectory.innerHTML = '<option value="">All Directories</option>' +
-                Array.from(directories).sort().map(d =>
-                    `<option value="${d}" ${currentDirs.includes(d) ? 'selected' : ''}>${d}</option>`
-                ).join('');
-
-            // Update file filter
-            filterFile.innerHTML = '<option value="">All Files</option>' +
-                Array.from(files).sort().map(f =>
-                    `<option value="${f}" ${currentFiles.includes(f) ? 'selected' : ''}>${f}</option>`
-                ).join('');
-
-            // Get selected filter values
-            const selectedAgents = Array.from(filterAgent.selectedOptions).map(o => o.value).filter(v => v !== '');
-            const selectedDirs = Array.from(filterDirectory.selectedOptions).map(o => o.value).filter(v => v !== '');
-            const selectedFiles = Array.from(filterFile.selectedOptions).map(o => o.value).filter(v => v !== '');
-
-            // Build graph structure
-            const nodes = [];
-            const links = [];
-            const resourceToNodes = new Map();
-
-            // Create nodes for each tool call (with filtering)
-            toolCallData.forEach((call, idx) => {
-                // Apply agent filter
-                if (selectedAgents.length > 0 && !selectedAgents.includes(call.agentId)) {
-                    return;
-                }
-
-                const resources = extractResources(call);
-
-                // Apply directory filter
-                if (selectedDirs.length > 0) {
-                    const hasMatchingDir = resources.some(res =>
-                        res.directory && selectedDirs.includes(res.directory)
-                    );
-                    if (!hasMatchingDir) return;
-                }
-
-                // Apply file filter
-                if (selectedFiles.length > 0) {
-                    const hasMatchingFile = resources.some(res =>
-                        selectedFiles.includes(res.value)
-                    );
-                    if (!hasMatchingFile) return;
-                }
-
-                const node = {
-                    id: idx,
-                    toolCall: call,
-                    agentId: call.agentId,
-                    toolName: call.toolName,
-                    weight: call.weight,
-                    resources: resources
-                };
-                nodes.push(node);
-
-                // Map resources to nodes
-                resources.forEach(res => {
-                    let key;
-                    if (clusterBy === 'directory') {
-                        key = res.directory || res.value;
-                    } else if (clusterBy === 'file') {
-                        key = res.value;
-                    } else { // agent
-                        key = call.agentId;
-                    }
-
-                    if (!resourceToNodes.has(key)) {
-                        resourceToNodes.set(key, []);
-                    }
-                    resourceToNodes.get(key).push(node);
-                });
-            });
-
-            // Create links between nodes that share resources
-            const linkSet = new Set();
-            resourceToNodes.forEach((nodeList, resource) => {
-                if (nodeList.length >= minLinks) {
-                    for (let i = 0; i < nodeList.length; i++) {
-                        for (let j = i + 1; j < nodeList.length; j++) {
-                            const linkId = [nodeList[i].id, nodeList[j].id].sort().join('-');
-                            if (!linkSet.has(linkId)) {
-                                linkSet.add(linkId);
-                                links.push({
-                                    source: nodeList[i].id,
-                                    target: nodeList[j].id,
-                                    resource: resource
-                                });
-                            }
-                        }
-                    }
-                }
-            });
-
-            // Filter nodes to only include those with links
-            const connectedNodeIds = new Set();
-            links.forEach(link => {
-                connectedNodeIds.add(link.source);
-                connectedNodeIds.add(link.target);
-            });
-            const filteredNodes = nodes.filter(n => connectedNodeIds.has(n.id));
-
-            if (filteredNodes.length === 0) {
-                svg.append('text')
-                    .attr('x', 400)
-                    .attr('y', 200)
-                    .attr('text-anchor', 'middle')
-                    .attr('fill', '#999')
-                    .text('No connected tool calls found. Try adjusting filters.');
-                return;
-            }
-
-            // Set up SVG dimensions
-            const width = 1400;
-            const height = 800;
-            svg.attr('width', width).attr('height', height);
-
-            // Create force simulation
-            const simulation = d3.forceSimulation(filteredNodes)
-                .force('link', d3.forceLink(links).id(d => d.id).distance(100))
-                .force('charge', d3.forceManyBody().strength(-300))
-                .force('center', d3.forceCenter(width / 2, height / 2))
-                .force('collision', d3.forceCollide().radius(30));
-
-            // Create zoom behavior
-            const g = svg.append('g');
-            const zoom = d3.zoom()
-                .scaleExtent([0.1, 4])
-                .on('zoom', (event) => {
-                    g.attr('transform', event.transform);
-                });
-            svg.call(zoom);
-
-            // Restore previous zoom transform if it exists
-            if (clusteringZoomTransform) {
-                g.attr('transform', clusteringZoomTransform);
-            }
-
-            // Draw links
-            const link = g.append('g')
-                .selectAll('line')
-                .data(links)
-                .join('line')
-                .attr('class', 'cluster-link')
-                .attr('stroke-width', 1);
-
-            // Draw nodes
-            const node = g.append('g')
-                .selectAll('circle')
-                .data(filteredNodes)
-                .join('circle')
-                .attr('class', 'cluster-node')
-                .attr('r', d => 5 + Math.sqrt(d.weight) * 2)
-                .attr('fill', d => toolColors(d.toolName))
-                .attr('stroke', d => d.toolCall.weightCategory.color)
-                .attr('stroke-width', 2)
-                .attr('opacity', 0.8)
-                .call(d3.drag()
-                    .on('start', dragstarted)
-                    .on('drag', dragged)
-                    .on('end', dragended))
-                .on('mouseover', function(event, d) {
-                    const tooltip = document.getElementById('tooltip');
-                    tooltip.style.display = 'block';
-
-                    const resourcesText = d.resources.length > 0 ?
-                        d.resources.map(r => `<div>• ${r.type}: ${r.value}</div>`).join('') :
-                        '<div>• No resources identified</div>';
-
-                    tooltip.innerHTML = `
-                        <div class="tooltip-title">${d.toolName} by ${d.agentId}</div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Weight:</span>
-                            <span class="weight-badge weight-${d.toolCall.weightCategory.class}">
-                                ${d.weight.toFixed(1)}
-                            </span>
-                        </div>
-                        <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                            <div class="tooltip-label">Resources:</div>
-                            ${resourcesText}
-                        </div>
-                    `;
-                    tooltip.style.left = event.pageX + 10 + 'px';
-                    tooltip.style.top = event.pageY + 10 + 'px';
-
-                    // Highlight connected nodes
-                    node.style('opacity', n => {
-                        if (n.id === d.id) return 1;
-                        const isConnected = links.some(l =>
-                            (l.source.id === d.id && l.target.id === n.id) ||
-                            (l.target.id === d.id && l.source.id === n.id)
-                        );
-                        return isConnected ? 0.8 : 0.2;
-                    });
-                    link.style('opacity', l =>
-                        (l.source.id === d.id || l.target.id === d.id) ? 0.8 : 0.1
-                    );
-                })
-                .on('mouseout', () => {
-                    document.getElementById('tooltip').style.display = 'none';
-                    node.style('opacity', 0.8);
-                    link.style('opacity', 0.3);
-                });
-
-            // Update positions on tick
-            simulation.on('tick', () => {
-                link
-                    .attr('x1', d => d.source.x)
-                    .attr('y1', d => d.source.y)
-                    .attr('x2', d => d.target.x)
-                    .attr('y2', d => d.target.y);
-
-                node
-                    .attr('cx', d => d.x)
-                    .attr('cy', d => d.y);
-            });
-
-            // Drag functions
-            function dragstarted(event, d) {
-                if (!event.active) simulation.alphaTarget(0.3).restart();
-                d.fx = d.x;
-                d.fy = d.y;
-            }
-
-            function dragged(event, d) {
-                d.fx = event.x;
-                d.fy = event.y;
-            }
-
-            function dragended(event, d) {
-                if (!event.active) simulation.alphaTarget(0);
-                d.fx = null;
-                d.fy = null;
-            }
-
-            // Update legend
-            const legend = document.getElementById('clusterLegend');
-            const clusterStats = new Map();
-            resourceToNodes.forEach((nodeList, resource) => {
-                if (nodeList.length >= minLinks) {
-                    clusterStats.set(resource, nodeList.length);
-                }
-            });
-
-            const sortedClusters = Array.from(clusterStats.entries())
-                .sort((a, b) => b[1] - a[1])
-                .slice(0, 10);
-
-            // Build active filters display
-            const activeFilters = [];
-            if (selectedAgents.length > 0) {
-                activeFilters.push(`Agents: ${selectedAgents.join(', ')}`);
-            }
-            if (selectedDirs.length > 0) {
-                activeFilters.push(`Directories: ${selectedDirs.join(', ')}`);
-            }
-            if (selectedFiles.length > 0) {
-                activeFilters.push(`Files: ${selectedFiles.join(', ')}`);
-            }
-
-            const filtersHtml = activeFilters.length > 0 ? `
-                <div style="margin-bottom: 15px; padding: 10px; background: #e3f2fd; border-left: 4px solid #2196F3; border-radius: 3px;">
-                    <strong>Active Filters:</strong>
-                    <div style="margin-top: 5px;">
-                        ${activeFilters.map(f => `• ${f}`).join('<br>')}
-                    </div>
-                </div>
-            ` : '';
-
-            legend.innerHTML = `
-                ${filtersHtml}
-                <strong>Top Resource Clusters (by ${clusterBy}):</strong>
-                <div style="margin-top: 10px;">
-                    ${sortedClusters.map(([resource, count]) => `
-                        <div style="margin: 5px 0; padding: 5px; background: #f9f9f9; border-radius: 3px;">
-                            <strong>${resource || '(root)'}</strong>: ${count} tool calls
-                        </div>
-                    `).join('')}
-                </div>
-                <div style="margin-top: 15px; padding-top: 15px; border-top: 1px solid #ddd;">
-                    <strong>Graph Statistics:</strong>
-                    <div style="margin-top: 5px;">
-                        • ${filteredNodes.length} connected tool calls (of ${toolCallData.length} total)<br>
-                        • ${links.length} connections<br>
-                        • ${clusterStats.size} resource clusters
-                    </div>
-                </div>
-            `;
-        }
-
-        // Load and process token file
-        function loadAndProcessTokenFile(file) {
-            const reader = new FileReader();
-            reader.onload = (e) => {
-                const lines = e.target.result.split('\n');
-                tokenData = lines
-                    .filter(line => line.trim())
-                    .map(line => {
-                        try {
-                            return JSON.parse(line);
-                        } catch (err) {
-                            return null;
-                        }
-                    })
-                    .filter(entry => entry && entry.message && entry.message.usage)
-                    .map(entry => ({
-                        timestamp: new Date(entry.timestamp),
-                        inputTokens: entry.message.usage.input_tokens || 0,
-                        cacheRead: entry.message.usage.cache_read_input_tokens || 0,
-                        cacheCreation: entry.message.usage.cache_creation_input_tokens || 0,
-                        outputTokens: entry.message.usage.output_tokens || 0
-                    }));
-
-                // Sort by timestamp
-                tokenData.sort((a, b) => a.timestamp - b.timestamp);
-
-                // Add cumulative totals
-                let cumInput = 0, cumCacheRead = 0, cumCacheCreation = 0, cumOutput = 0;
-                tokenData.forEach(d => {
-                    cumInput += d.inputTokens;
-                    cumCacheRead += d.cacheRead;
-                    cumCacheCreation += d.cacheCreation;
-                    cumOutput += d.outputTokens;
-                    d.cumInputTokens = cumInput;
-                    d.cumCacheRead = cumCacheRead;
-                    d.cumCacheCreation = cumCacheCreation;
-                    d.cumOutputTokens = cumOutput;
-                    d.cumTotal = cumInput + cumCacheRead + cumCacheCreation + cumOutput;
-                });
-
-                renderTokenTracking();
-            };
-            reader.readAsText(file);
-        }
-
-        // Track visibility state for each chart
-        const tokenChartVisibility = {
-            inputTokens: true,
-            cacheRead: true,
-            cacheCreation: true,
-            outputTokens: true
-        };
-
-        const cacheChartVisibility = {
-            cacheRead: true,
-            cacheCreation: true
-        };
-
-        const cumChartVisibility = {
-            cumInputTokens: true,
-            cumOutputTokens: true
-        };
-
-        // Render token tracking
-        function renderTokenTracking() {
-            if (!tokenData || tokenData.length === 0) {
-                document.getElementById('tokenStatsContainer').innerHTML = `
-                    <div style="text-align: center; padding: 20px; color: #666;">
-                        No token data loaded. Please select a session log JSONL file.
-                    </div>
-                `;
-                return;
-            }
-
-            // Calculate statistics
-            const totalInput = d3.sum(tokenData, d => d.inputTokens);
-            const totalCacheRead = d3.sum(tokenData, d => d.cacheRead);
-            const totalCacheCreation = d3.sum(tokenData, d => d.cacheCreation);
-            const totalOutput = d3.sum(tokenData, d => d.outputTokens);
-            const totalTokens = totalInput + totalCacheRead + totalCacheCreation + totalOutput;
-            const cacheHitRate = totalCacheCreation > 0
-                ? (totalCacheRead / (totalCacheRead + totalCacheCreation) * 100).toFixed(1)
-                : 0;
-
-            // Render stats cards
-            document.getElementById('tokenStatsContainer').innerHTML = `
-                <div class="stat-card success">
-                    <div class="stat-label">Total Tokens</div>
-                    <div class="stat-value">${totalTokens.toLocaleString()}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Input Tokens</div>
-                    <div class="stat-value">${totalInput.toLocaleString()}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Output Tokens</div>
-                    <div class="stat-value">${totalOutput.toLocaleString()}</div>
-                </div>
-                <div class="stat-card warning">
-                    <div class="stat-label">Cache Hit Rate</div>
-                    <div class="stat-value">${cacheHitRate}%</div>
-                </div>
-            `;
-
-            // Chart dimensions
-            const margin = { top: 20, right: 180, bottom: 40, left: 60 };
-            const width = 500;
-            const height = 300;
-
-            // 1. Token Usage Over Time
-            const tokenSvg = d3.select('#tokenChart')
-                .attr('width', width + margin.left + margin.right)
-                .attr('height', height + margin.top + margin.bottom);
-
-            tokenSvg.selectAll('*').remove();
-
-            const tokenG = tokenSvg.append('g')
-                .attr('transform', `translate(${margin.left},${margin.top})`);
-
-            const xScale = d3.scaleTime()
-                .domain(d3.extent(tokenData, d => d.timestamp))
-                .range([0, width]);
-
-            const yScaleToken = d3.scaleLinear()
-                .domain([0, d3.max(tokenData, d => Math.max(
-                    d.inputTokens, d.cacheRead, d.cacheCreation, d.outputTokens
-                )) * 1.1])
-                .range([height, 0]);
-
-            // Axes
-            tokenG.append('g')
-                .attr('transform', `translate(0,${height})`)
-                .call(d3.axisBottom(xScale).ticks(5))
-                .selectAll('text')
-                .style('font-size', '11px');
-
-            tokenG.append('g')
-                .call(d3.axisLeft(yScaleToken).ticks(5))
-                .selectAll('text')
-                .style('font-size', '11px');
-
-            // Grid lines
-            tokenG.append('g')
-                .attr('class', 'grid')
-                .attr('opacity', 0.1)
-                .call(d3.axisLeft(yScaleToken)
-                    .ticks(5)
-                    .tickSize(-width)
-                    .tickFormat(''));
-
-            // Lines
-            const lineColors = {
-                inputTokens: '#4facfe',
-                cacheRead: '#43e97b',
-                cacheCreation: '#fa709a',
-                outputTokens: '#f093fb'
-            };
-
-            const lineGenerator = d3.line()
-                .x(d => xScale(d.timestamp))
-                .curve(d3.curveMonotoneX);
-
-            const tokenLines = {};
-            Object.entries(lineColors).forEach(([key, color]) => {
-                tokenLines[key] = {
-                    line: tokenG.append('path')
-                        .datum(tokenData)
-                        .attr('class', `line-${key}`)
-                        .attr('fill', 'none')
-                        .attr('stroke', color)
-                        .attr('stroke-width', 2)
-                        .attr('d', lineGenerator.y(d => yScaleToken(d[key])))
-                        .style('opacity', tokenChartVisibility[key] ? 1 : 0),
-                    points: tokenG.selectAll(`.point-${key}`)
-                        .data(tokenData)
-                        .join('circle')
-                        .attr('class', `point-${key}`)
-                        .attr('cx', d => xScale(d.timestamp))
-                        .attr('cy', d => yScaleToken(d[key]))
-                        .attr('r', 3)
-                        .attr('fill', color)
-                        .style('opacity', tokenChartVisibility[key] ? 0.7 : 0)
-                };
-            });
-
-            // Legend for token chart
-            const tokenLegend = [
-                { label: 'Input Tokens', color: lineColors.inputTokens },
-                { label: 'Cache Read', color: lineColors.cacheRead },
-                { label: 'Cache Creation', color: lineColors.cacheCreation },
-                { label: 'Output Tokens', color: lineColors.outputTokens }
-            ];
-
-            tokenLegend.forEach((item, i) => {
-                const key = Object.keys(lineColors)[i];
-                const legendG = tokenG.append('g')
-                    .attr('transform', `translate(${width + 20}, ${10 + i * 22})`)
-                    .style('cursor', 'pointer')
-                    .on('click', function() {
-                        tokenChartVisibility[key] = !tokenChartVisibility[key];
-                        const visible = tokenChartVisibility[key];
-
-                        // Toggle line and points
-                        tokenLines[key].line.style('opacity', visible ? 1 : 0);
-                        tokenLines[key].points.style('opacity', visible ? 0.7 : 0);
-
-                        // Update legend appearance
-                        d3.select(this).select('line')
-                            .style('opacity', visible ? 1 : 0.3);
-                        d3.select(this).select('text')
-                            .style('opacity', visible ? 1 : 0.4)
-                            .style('text-decoration', visible ? 'none' : 'line-through');
-                    });
-
-                legendG.append('line')
-                    .attr('x1', 0)
-                    .attr('x2', 20)
-                    .attr('y1', 0)
-                    .attr('y2', 0)
-                    .attr('stroke', item.color)
-                    .attr('stroke-width', 2)
-                    .style('opacity', tokenChartVisibility[key] ? 1 : 0.3);
-
-                legendG.append('text')
-                    .attr('x', 25)
-                    .attr('y', 4)
-                    .style('font-size', '10px')
-                    .style('opacity', tokenChartVisibility[key] ? 1 : 0.4)
-                    .style('text-decoration', tokenChartVisibility[key] ? 'none' : 'line-through')
-                    .text(item.label);
-            });
-
-            // 2. Cache Efficiency Chart
-            const cacheSvg = d3.select('#cacheChart')
-                .attr('width', width + margin.left + margin.right)
-                .attr('height', height + margin.top + margin.bottom);
-
-            cacheSvg.selectAll('*').remove();
-
-            const cacheG = cacheSvg.append('g')
-                .attr('transform', `translate(${margin.left},${margin.top})`);
-
-            const yScaleCache = d3.scaleLinear()
-                .domain([0, d3.max(tokenData, d => Math.max(d.cacheRead, d.cacheCreation)) * 1.1])
-                .range([height, 0]);
-
-            // Axes
-            cacheG.append('g')
-                .attr('transform', `translate(0,${height})`)
-                .call(d3.axisBottom(xScale).ticks(5))
-                .selectAll('text')
-                .style('font-size', '11px');
-
-            cacheG.append('g')
-                .call(d3.axisLeft(yScaleCache).ticks(5))
-                .selectAll('text')
-                .style('font-size', '11px');
-
-            // Grid
-            cacheG.append('g')
-                .attr('class', 'grid')
-                .attr('opacity', 0.1)
-                .call(d3.axisLeft(yScaleCache)
-                    .ticks(5)
-                    .tickSize(-width)
-                    .tickFormat(''));
-
-            // Cache Read (hits) - Area
-            const areaGenerator = d3.area()
-                .x(d => xScale(d.timestamp))
-                .y0(height)
-                .y1(d => yScaleCache(d.cacheRead))
-                .curve(d3.curveMonotoneX);
-
-            const cacheReadArea = cacheG.append('path')
-                .datum(tokenData)
-                .attr('fill', lineColors.cacheRead)
-                .attr('opacity', cacheChartVisibility.cacheRead ? 0.3 : 0)
-                .attr('d', areaGenerator);
-
-            const cacheReadLine = cacheG.append('path')
-                .datum(tokenData)
-                .attr('fill', 'none')
-                .attr('stroke', lineColors.cacheRead)
-                .attr('stroke-width', 2)
-                .attr('d', lineGenerator.y(d => yScaleCache(d.cacheRead)))
-                .style('opacity', cacheChartVisibility.cacheRead ? 1 : 0);
-
-            // Cache Creation (misses) - Area
-            const areaMissGenerator = d3.area()
-                .x(d => xScale(d.timestamp))
-                .y0(height)
-                .y1(d => yScaleCache(d.cacheCreation))
-                .curve(d3.curveMonotoneX);
-
-            const cacheCreationArea = cacheG.append('path')
-                .datum(tokenData)
-                .attr('fill', lineColors.cacheCreation)
-                .attr('opacity', cacheChartVisibility.cacheCreation ? 0.3 : 0)
-                .attr('d', areaMissGenerator);
-
-            const cacheCreationLine = cacheG.append('path')
-                .datum(tokenData)
-                .attr('fill', 'none')
-                .attr('stroke', lineColors.cacheCreation)
-                .attr('stroke-width', 2)
-                .attr('d', lineGenerator.y(d => yScaleCache(d.cacheCreation)))
-                .style('opacity', cacheChartVisibility.cacheCreation ? 1 : 0);
-
-            const cacheLines = {
-                cacheRead: { area: cacheReadArea, line: cacheReadLine },
-                cacheCreation: { area: cacheCreationArea, line: cacheCreationLine }
-            };
-
-            // Legend
-            const cacheLegend = [
-                { label: 'Cache Read (Hits)', color: lineColors.cacheRead },
-                { label: 'Cache Creation (Misses)', color: lineColors.cacheCreation }
-            ];
-
-            cacheLegend.forEach((item, i) => {
-                const key = i === 0 ? 'cacheRead' : 'cacheCreation';
-                const legendG = cacheG.append('g')
-                    .attr('transform', `translate(${width + 20}, ${10 + i * 30})`)
-                    .style('cursor', 'pointer')
-                    .on('click', function() {
-                        cacheChartVisibility[key] = !cacheChartVisibility[key];
-                        const visible = cacheChartVisibility[key];
-
-                        // Toggle area and line
-                        cacheLines[key].area.attr('opacity', visible ? 0.3 : 0);
-                        cacheLines[key].line.style('opacity', visible ? 1 : 0);
-
-                        // Update legend appearance
-                        d3.select(this).select('rect')
-                            .style('opacity', visible ? 0.5 : 0.2);
-                        d3.select(this).select('text')
-                            .style('opacity', visible ? 1 : 0.4)
-                            .style('text-decoration', visible ? 'none' : 'line-through');
-                    });
-
-                legendG.append('rect')
-                    .attr('x', 0)
-                    .attr('y', -8)
-                    .attr('width', 20)
-                    .attr('height', 10)
-                    .attr('fill', item.color)
-                    .style('opacity', cacheChartVisibility[key] ? 0.5 : 0.2);
-
-                legendG.append('text')
-                    .attr('x', 25)
-                    .attr('y', 0)
-                    .style('font-size', '10px')
-                    .style('opacity', cacheChartVisibility[key] ? 1 : 0.4)
-                    .style('text-decoration', cacheChartVisibility[key] ? 'none' : 'line-through')
-                    .text(item.label);
-            });
-
-            // 3. Cumulative Token Usage - Input vs Output
-            const cumSvg = d3.select('#cumulativeChart')
-                .attr('width', width * 2 + margin.left + margin.right)
-                .attr('height', height + margin.top + margin.bottom);
-
-            cumSvg.selectAll('*').remove();
-
-            const cumG = cumSvg.append('g')
-                .attr('transform', `translate(${margin.left},${margin.top})`);
-
-            const xScaleCum = d3.scaleTime()
-                .domain(d3.extent(tokenData, d => d.timestamp))
-                .range([0, width * 2]);
-
-            const yScaleCum = d3.scaleLinear()
-                .domain([0, d3.max(tokenData, d => Math.max(d.cumInputTokens, d.cumOutputTokens)) * 1.05])
-                .range([height, 0]);
-
-            // Axes
-            cumG.append('g')
-                .attr('transform', `translate(0,${height})`)
-                .call(d3.axisBottom(xScaleCum).ticks(8))
-                .selectAll('text')
-                .style('font-size', '11px');
-
-            cumG.append('g')
-                .call(d3.axisLeft(yScaleCum).ticks(5))
-                .selectAll('text')
-                .style('font-size', '11px');
-
-            // Grid
-            cumG.append('g')
-                .attr('class', 'grid')
-                .attr('opacity', 0.1)
-                .call(d3.axisLeft(yScaleCum)
-                    .ticks(5)
-                    .tickSize(-width * 2)
-                    .tickFormat(''));
-
-            // Line generator
-            const cumLineGenerator = d3.line()
-                .x(d => xScaleCum(d.timestamp))
-                .curve(d3.curveMonotoneX);
-
-            // Cumulative Input Tokens (area + line)
-            const inputAreaGen = d3.area()
-                .x(d => xScaleCum(d.timestamp))
-                .y0(height)
-                .y1(d => yScaleCum(d.cumInputTokens))
-                .curve(d3.curveMonotoneX);
-
-            const cumInputArea = cumG.append('path')
-                .datum(tokenData)
-                .attr('fill', lineColors.inputTokens)
-                .attr('opacity', cumChartVisibility.cumInputTokens ? 0.3 : 0)
-                .attr('d', inputAreaGen);
-
-            const cumInputLine = cumG.append('path')
-                .datum(tokenData)
-                .attr('fill', 'none')
-                .attr('stroke', lineColors.inputTokens)
-                .attr('stroke-width', 3)
-                .attr('d', cumLineGenerator.y(d => yScaleCum(d.cumInputTokens)))
-                .style('opacity', cumChartVisibility.cumInputTokens ? 1 : 0);
-
-            // Cumulative Output Tokens (area + line)
-            const outputAreaGen = d3.area()
-                .x(d => xScaleCum(d.timestamp))
-                .y0(height)
-                .y1(d => yScaleCum(d.cumOutputTokens))
-                .curve(d3.curveMonotoneX);
-
-            const cumOutputArea = cumG.append('path')
-                .datum(tokenData)
-                .attr('fill', lineColors.outputTokens)
-                .attr('opacity', cumChartVisibility.cumOutputTokens ? 0.3 : 0)
-                .attr('d', outputAreaGen);
-
-            const cumOutputLine = cumG.append('path')
-                .datum(tokenData)
-                .attr('fill', 'none')
-                .attr('stroke', lineColors.outputTokens)
-                .attr('stroke-width', 3)
-                .attr('d', cumLineGenerator.y(d => yScaleCum(d.cumOutputTokens)))
-                .style('opacity', cumChartVisibility.cumOutputTokens ? 1 : 0);
-
-            const cumLines = {
-                cumInputTokens: { area: cumInputArea, line: cumInputLine },
-                cumOutputTokens: { area: cumOutputArea, line: cumOutputLine }
-            };
-
-            // Legend
-            const cumLegend = [
-                { label: 'Cumulative Input Tokens', color: lineColors.inputTokens },
-                { label: 'Cumulative Output Tokens', color: lineColors.outputTokens }
-            ];
-
-            cumLegend.forEach((item, i) => {
-                const key = i === 0 ? 'cumInputTokens' : 'cumOutputTokens';
-                const legendG = cumG.append('g')
-                    .attr('transform', `translate(${width * 2 + 20}, ${10 + i * 30})`)
-                    .style('cursor', 'pointer')
-                    .on('click', function() {
-                        cumChartVisibility[key] = !cumChartVisibility[key];
-                        const visible = cumChartVisibility[key];
-
-                        // Toggle area and line
-                        cumLines[key].area.attr('opacity', visible ? 0.3 : 0);
-                        cumLines[key].line.style('opacity', visible ? 1 : 0);
-
-                        // Update legend appearance
-                        d3.select(this).select('line')
-                            .style('opacity', visible ? 1 : 0.3);
-                        d3.select(this).select('text')
-                            .style('opacity', visible ? 1 : 0.4)
-                            .style('text-decoration', visible ? 'none' : 'line-through');
-                    });
-
-                legendG.append('line')
-                    .attr('x1', 0)
-                    .attr('x2', 25)
-                    .attr('y1', 0)
-                    .attr('y2', 0)
-                    .attr('stroke', item.color)
-                    .attr('stroke-width', 3)
-                    .style('opacity', cumChartVisibility[key] ? 1 : 0.3);
-
-                legendG.append('text')
-                    .attr('x', 30)
-                    .attr('y', 4)
-                    .style('font-size', '10px')
-                    .style('opacity', cumChartVisibility[key] ? 1 : 0.4)
-                    .style('text-decoration', cumChartVisibility[key] ? 'none' : 'line-through')
-                    .text(item.label);
-            });
-
-            // Y-axis label
-            cumG.append('text')
-                .attr('transform', 'rotate(-90)')
-                .attr('y', -45)
-                .attr('x', -height / 2)
-                .attr('text-anchor', 'middle')
-                .style('font-size', '12px')
-                .text('Cumulative Tokens');
-        }
-
-        // Render text analysis
-        function renderTextAnalysis() {
-            if (!textBlockData || textBlockData.length === 0) {
-                document.getElementById('textStatsContainer').innerHTML = `
-                    <div style="text-align: center; padding: 20px; color: #666;">
-                        No text block data available. Make sure you're using the updated SDK that logs text blocks.
-                    </div>
-                `;
-                return;
-            }
-
-            // Sort data by timestamp
-            const sortedData = [...textBlockData].sort((a, b) => a.timestamp - b.timestamp);
-
-            // Estimate tokens (rough approximation: 1 token ≈ 4 characters for English text)
-            const dataWithTokens = sortedData.map(d => ({
-                ...d,
-                estimatedTokens: Math.round(d.textLength / 4)
-            }));
-
-            // Calculate statistics
-            const totalBlocks = dataWithTokens.length;
-            const totalTokens = d3.sum(dataWithTokens, d => d.estimatedTokens);
-            const avgTokens = d3.mean(dataWithTokens, d => d.estimatedTokens);
-            const maxTokens = d3.max(dataWithTokens, d => d.estimatedTokens);
-
-            // Render stats cards
-            document.getElementById('textStatsContainer').innerHTML = `
-                <div class="stat-card success">
-                    <div class="stat-label">Total Text Blocks</div>
-                    <div class="stat-value">${totalBlocks.toLocaleString()}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Total Tokens (est.)</div>
-                    <div class="stat-value">${totalTokens.toLocaleString()}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Avg Tokens/Block</div>
-                    <div class="stat-value">${Math.round(avgTokens)}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Max Tokens/Block</div>
-                    <div class="stat-value">${maxTokens.toLocaleString()}</div>
-                </div>
-            `;
-
-            // Chart dimensions
-            const margin = { top: 40, right: 80, bottom: 60, left: 80 };
-            const width = 1200;
-            const height = 400;
-
-            // Create SVG
-            const svg = d3.select('#textFrequencyChart')
-                .attr('width', width + margin.left + margin.right)
-                .attr('height', height + margin.top + margin.bottom);
-
-            svg.selectAll('*').remove();
-
-            const g = svg.append('g')
-                .attr('transform', `translate(${margin.left},${margin.top})`);
-
-            // Scales
-            const minTime = d3.min(dataWithTokens, d => d.timestamp);
-            const xScale = d3.scaleLinear()
-                .domain([0, dataWithTokens.length - 1])
-                .range([0, width]);
-
-            const yScale = d3.scaleLinear()
-                .domain([0, maxTokens * 1.1])
-                .range([height, 0]);
-
-            // Axes
-            g.append('g')
-                .attr('transform', `translate(0,${height})`)
-                .call(d3.axisBottom(xScale).ticks(10).tickFormat(d => `#${d + 1}`))
-                .selectAll('text')
-                .style('font-size', '11px')
-                .attr('transform', 'rotate(-45)')
-                .style('text-anchor', 'end');
-
-            g.append('g')
-                .call(d3.axisLeft(yScale).ticks(10))
-                .selectAll('text')
-                .style('font-size', '11px');
-
-            // Axis labels
-            g.append('text')
-                .attr('x', width / 2)
-                .attr('y', height + 50)
-                .attr('text-anchor', 'middle')
-                .style('font-size', '12px')
-                .style('font-weight', 'bold')
-                .text('Text Block Sequence');
-
-            g.append('text')
-                .attr('transform', 'rotate(-90)')
-                .attr('x', -height / 2)
-                .attr('y', -60)
-                .attr('text-anchor', 'middle')
-                .style('font-size', '12px')
-                .style('font-weight', 'bold')
-                .text('Estimated Tokens');
-
-            // Title
-            g.append('text')
-                .attr('x', width / 2)
-                .attr('y', -20)
-                .attr('text-anchor', 'middle')
-                .style('font-size', '14px')
-                .style('font-weight', 'bold')
-                .text('Token Count per Text Block Over Time');
-
-            // Color scale by agent
-            const agents = Array.from(new Set(dataWithTokens.map(d => d.agentId)));
-            const colorScale = d3.scaleOrdinal()
-                .domain(agents)
-                .range(d3.schemeCategory10);
-
-            // Draw line
-            const line = d3.line()
-                .x((d, i) => xScale(i))
-                .y(d => yScale(d.estimatedTokens))
-                .curve(d3.curveMonotoneX);
-
-            g.append('path')
-                .datum(dataWithTokens)
-                .attr('fill', 'none')
-                .attr('stroke', '#667eea')
-                .attr('stroke-width', 2)
-                .attr('d', line)
-                .attr('opacity', 0.7);
-
-            // Draw points
-            g.selectAll('circle')
-                .data(dataWithTokens)
-                .join('circle')
-                .attr('cx', (d, i) => xScale(i))
-                .attr('cy', d => yScale(d.estimatedTokens))
-                .attr('r', 5)
-                .attr('fill', d => colorScale(d.agentId))
-                .attr('stroke', '#333')
-                .attr('stroke-width', 1)
-                .attr('opacity', 0.8)
-                .style('cursor', 'pointer')
-                .on('mouseover', function(event, d) {
-                    d3.select(this).attr('r', 8).attr('opacity', 1);
-                    const tooltip = document.getElementById('tooltip');
-                    tooltip.style.display = 'block';
-                    tooltip.innerHTML = `
-                        <div class="tooltip-title">📝 Text Block</div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Agent:</span>
-                            <span>${d.agentId}</span>
-                        </div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Time:</span>
-                            <span>${d.timestamp.toLocaleTimeString()}</span>
-                        </div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Tokens (est.):</span>
-                            <span>${d.estimatedTokens.toLocaleString()}</span>
-                        </div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Characters:</span>
-                            <span>${d.textLength.toLocaleString()}</span>
-                        </div>
-                        <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.3);">
-                            <div class="tooltip-label">Preview:</div>
-                            <div style="font-size: 11px; margin-top: 4px; max-width: 300px; word-break: break-word;">
-                                ${d.text.substring(0, 150)}${d.text.length > 150 ? '...' : ''}
-                            </div>
-                        </div>
-                    `;
-                    tooltip.style.left = event.pageX + 10 + 'px';
-                    tooltip.style.top = event.pageY + 10 + 'px';
-                })
-                .on('mouseout', function() {
-                    d3.select(this).attr('r', 5).attr('opacity', 0.8);
-                    document.getElementById('tooltip').style.display = 'none';
-                });
-
-            // Legend
-            const legend = g.append('g')
-                .attr('transform', `translate(${width + 10}, 0)`);
-
-            legend.append('text')
-                .attr('x', 0)
-                .attr('y', 0)
-                .style('font-size', '12px')
-                .style('font-weight', 'bold')
-                .text('Agents');
-
-            agents.forEach((agent, i) => {
-                const legendItem = legend.append('g')
-                    .attr('transform', `translate(0, ${20 + i * 25})`);
-
-                legendItem.append('circle')
-                    .attr('cx', 8)
-                    .attr('cy', 0)
-                    .attr('r', 5)
-                    .attr('fill', colorScale(agent))
-                    .attr('stroke', '#333')
-                    .attr('stroke-width', 1);
-
-                legendItem.append('text')
-                    .attr('x', 20)
-                    .attr('y', 4)
-                    .style('font-size', '11px')
-                    .text(agent);
-            });
-
-            // Hide unused charts
-            d3.select('#textLengthChart').style('display', 'none');
-            d3.select('#textByAgentChart').style('display', 'none');
-        }
-
-        // Render reasoning pattern analysis
-        function renderReasoningPatterns() {
-            const container = document.getElementById('reasoningContainer');
-            const statsContainer = document.getElementById('reasoningStatsContainer');
-
-            if (!llmEventData || llmEventData.length === 0) {
-                container.innerHTML = `
-                    <div style="text-align: center; padding: 40px 20px; color: #666;">
-                        <h4>No LLM call data available</h4>
-                        <p>Run an agent session with the updated callbacks to see reasoning pattern analysis.</p>
-                        <p style="margin-top: 15px; font-size: 13px;">Reasoning patterns detected:</p>
-                        <ul style="text-align: left; max-width: 500px; margin: 15px auto; font-size: 13px;">
-                            <li><strong>one_shot</strong> - Single prompt, direct response</li>
-                            <li><strong>chain_of_thought</strong> - Step-by-step reasoning in system prompt</li>
-                            <li><strong>react</strong> - Interleaved reasoning and tool use</li>
-                            <li><strong>react_multi_step</strong> - Multiple tool use iterations</li>
-                            <li><strong>multi_turn</strong> - Conversation with prior context</li>
-                            <li><strong>extended_thinking</strong> - Claude's thinking blocks</li>
-                        </ul>
-                    </div>
-                `;
-                statsContainer.innerHTML = '';
-                return;
-            }
-
-            // Aggregate reasoning patterns
-            const patternCounts = {};
-            const patternsByAgent = {};
-            const patternTokens = {};
-            let totalThinkingTokens = 0;
-            let callsWithThinking = 0;
-
-            llmEventData.forEach(event => {
-                const pattern = event.reasoningPattern?.type || 'unknown';
-                const agentId = event.agentId || 'MAIN_AGENT';
-                
-                // Count patterns
-                patternCounts[pattern] = (patternCounts[pattern] || 0) + 1;
-                
-                // Track by agent
-                if (!patternsByAgent[agentId]) {
-                    patternsByAgent[agentId] = {};
-                }
-                patternsByAgent[agentId][pattern] = (patternsByAgent[agentId][pattern] || 0) + 1;
-                
-                // Track tokens by pattern
-                if (!patternTokens[pattern]) {
-                    patternTokens[pattern] = { input: 0, output: 0, count: 0 };
-                }
-                patternTokens[pattern].input += event.inputTokens || 0;
-                patternTokens[pattern].output += event.outputTokens || 0;
-                patternTokens[pattern].count += 1;
-                
-                // Track thinking/extended reasoning
-                if (event.responseAnalysis?.has_thinking) {
-                    callsWithThinking++;
-                    totalThinkingTokens += event.responseAnalysis.thinking_length / 4; // Estimate tokens
-                }
-                
-                // Override pattern if has extended thinking
-                if (event.responseAnalysis?.has_thinking && pattern !== 'unknown') {
-                    const thinkingPattern = pattern + '_with_thinking';
-                    patternCounts[thinkingPattern] = (patternCounts[thinkingPattern] || 0) + 1;
-                    patternCounts[pattern] = Math.max(0, (patternCounts[pattern] || 0) - 1);
-                }
-            });
-
-            // Calculate stats
-            const totalCalls = llmEventData.length;
-            const avgContextWindow = d3.mean(llmEventData, d => d.reasoningPattern?.context_window_estimate || 0);
-            const reactCalls = (patternCounts['react'] || 0) + (patternCounts['react_multi_step'] || 0);
-            const cotCalls = Object.entries(patternCounts)
-                .filter(([k]) => k.includes('chain_of_thought'))
-                .reduce((sum, [, v]) => sum + v, 0);
-
-            // Render stats
-            statsContainer.innerHTML = `
-                <div class="stat-card success">
-                    <div class="stat-label">Total LLM Calls</div>
-                    <div class="stat-value">${totalCalls}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">ReAct (Tool Loop)</div>
-                    <div class="stat-value">${reactCalls}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Chain-of-Thought</div>
-                    <div class="stat-value">${cotCalls}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Extended Thinking</div>
-                    <div class="stat-value">${callsWithThinking}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Avg Context Window</div>
-                    <div class="stat-value">${formatTokens(avgContextWindow || 0)}</div>
-                </div>
-            `;
-
-            // Pattern colors
-            const patternColors = {
-                'one_shot': '#90EE90',
-                'multi_turn': '#87CEEB',
-                'chain_of_thought': '#DDA0DD',
-                'react': '#FFB347',
-                'react_multi_step': '#FF6B6B',
-                'unknown': '#CCCCCC',
-            };
-
-            // Build visualization
-            let html = `
-                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px;">
-                    <div style="background: white; padding: 20px; border-radius: 8px;">
-                        <h4 style="margin: 0 0 15px 0;">Pattern Distribution</h4>
-                        <div id="patternPieChart"></div>
-                        <div style="margin-top: 15px;">
-                            ${Object.entries(patternCounts)
-                                .filter(([, count]) => count > 0)
-                                .sort((a, b) => b[1] - a[1])
-                                .map(([pattern, count]) => {
-                                    const pct = (count / totalCalls * 100).toFixed(1);
-                                    const color = patternColors[pattern.replace('_with_thinking', '')] || '#CCCCCC';
-                                    const label = pattern.replace(/_/g, ' ').replace('with thinking', '+ thinking');
-                                    return `
-                                        <div style="display: flex; align-items: center; margin: 8px 0;">
-                                            <div style="width: 16px; height: 16px; border-radius: 4px; background: ${color}; margin-right: 10px;"></div>
-                                            <div style="flex: 1;">${label}</div>
-                                            <div style="font-weight: bold;">${count} (${pct}%)</div>
-                                        </div>
-                                    `;
-                                }).join('')}
-                        </div>
-                    </div>
-                    
-                    <div style="background: white; padding: 20px; border-radius: 8px;">
-                        <h4 style="margin: 0 0 15px 0;">Token Cost by Pattern</h4>
-                        <table style="width: 100%; border-collapse: collapse; font-size: 13px;">
-                            <thead>
-                                <tr style="border-bottom: 2px solid #ddd;">
-                                    <th style="text-align: left; padding: 8px;">Pattern</th>
-                                    <th style="text-align: right; padding: 8px;">Calls</th>
-                                    <th style="text-align: right; padding: 8px;">Input</th>
-                                    <th style="text-align: right; padding: 8px;">Output</th>
-                                    <th style="text-align: right; padding: 8px;">Avg Cost/Call</th>
-                                </tr>
-                            </thead>
-                            <tbody>
-                                ${Object.entries(patternTokens)
-                                    .sort((a, b) => (b[1].input + b[1].output) - (a[1].input + a[1].output))
-                                    .map(([pattern, data]) => {
-                                        const totalCost = (data.input / 1000000) * 3 + (data.output / 1000000) * 15;
-                                        const avgCost = data.count > 0 ? totalCost / data.count : 0;
-                                        const color = patternColors[pattern] || '#CCCCCC';
-                                        return `
-                                            <tr style="border-bottom: 1px solid #eee;">
-                                                <td style="padding: 8px;">
-                                                    <span style="display: inline-block; width: 12px; height: 12px; border-radius: 3px; background: ${color}; margin-right: 8px;"></span>
-                                                    ${pattern.replace(/_/g, ' ')}
-                                                </td>
-                                                <td style="text-align: right; padding: 8px;">${data.count}</td>
-                                                <td style="text-align: right; padding: 8px;">${formatTokens(data.input)}</td>
-                                                <td style="text-align: right; padding: 8px;">${formatTokens(data.output)}</td>
-                                                <td style="text-align: right; padding: 8px; font-weight: bold;">$${avgCost.toFixed(4)}</td>
-                                            </tr>
-                                        `;
-                                    }).join('')}
-                            </tbody>
-                        </table>
-                    </div>
-                </div>
-                
-                <div style="background: white; padding: 20px; border-radius: 8px; margin-top: 20px;">
-                    <h4 style="margin: 0 0 15px 0;">Reasoning Patterns by Agent</h4>
-                    <div style="max-height: 400px; overflow-y: auto;">
-                        <table style="width: 100%; border-collapse: collapse; font-size: 13px;">
-                            <thead style="position: sticky; top: 0; background: white;">
-                                <tr style="border-bottom: 2px solid #ddd;">
-                                    <th style="text-align: left; padding: 8px;">Agent</th>
-                                    ${Object.keys(patternColors).map(p => 
-                                        `<th style="text-align: center; padding: 8px; font-size: 11px;">${p.replace(/_/g, '<br>')}</th>`
-                                    ).join('')}
-                                    <th style="text-align: right; padding: 8px;">Total</th>
-                                </tr>
-                            </thead>
-                            <tbody>
-                                ${Object.entries(patternsByAgent)
-                                    .sort((a, b) => {
-                                        if (a[0] === 'MAIN_AGENT') return -1;
-                                        if (b[0] === 'MAIN_AGENT') return 1;
-                                        const aTotal = Object.values(a[1]).reduce((s, v) => s + v, 0);
-                                        const bTotal = Object.values(b[1]).reduce((s, v) => s + v, 0);
-                                        return bTotal - aTotal;
-                                    })
-                                    .slice(0, 20)
-                                    .map(([agentId, patterns]) => {
-                                        const total = Object.values(patterns).reduce((s, v) => s + v, 0);
-                                        return `
-                                            <tr style="border-bottom: 1px solid #eee;">
-                                                <td style="padding: 8px; font-weight: ${agentId === 'MAIN_AGENT' ? 'bold' : 'normal'};">
-                                                    ${agentId.length > 25 ? agentId.substring(0, 22) + '...' : agentId}
-                                                </td>
-                                                ${Object.keys(patternColors).map(p => {
-                                                    const count = patterns[p] || 0;
-                                                    const color = patternColors[p];
-                                                    return `<td style="text-align: center; padding: 8px;">
-                                                        ${count > 0 ? `<span style="background: ${color}; padding: 2px 8px; border-radius: 10px; font-size: 12px;">${count}</span>` : '-'}
-                                                    </td>`;
-                                                }).join('')}
-                                                <td style="text-align: right; padding: 8px; font-weight: bold;">${total}</td>
-                                            </tr>
-                                        `;
-                                    }).join('')}
-                            </tbody>
-                        </table>
-                    </div>
-                </div>
-                
-                ${callsWithThinking > 0 ? `
-                <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 8px; margin-top: 20px;">
-                    <h4 style="margin: 0 0 10px 0;">Extended Thinking Analysis</h4>
-                    <p style="margin: 0; opacity: 0.9;">
-                        ${callsWithThinking} LLM calls used extended thinking blocks, generating approximately 
-                        <strong>${formatTokens(totalThinkingTokens)}</strong> thinking tokens.
-                        This deep reasoning mode helps with complex tasks but increases token usage.
-                    </p>
-                </div>
-                ` : ''}
-                
-                ${(patternCounts['unknown'] || 0) > 0 ? `
-                <div style="background: #FFF3CD; padding: 20px; border-radius: 8px; margin-top: 20px; border: 1px solid #FFC107;">
-                    <h4 style="margin: 0 0 10px 0; color: #856404;">Unknown Patterns Debug Info</h4>
-                    <p style="margin: 0 0 10px 0; color: #856404; font-size: 13px;">
-                        ${patternCounts['unknown']} LLM calls have unknown reasoning patterns. This may be due to:
-                    </p>
-                    <ul style="margin: 0 0 10px 0; color: #856404; font-size: 13px; padding-left: 20px;">
-                        <li>Legacy log format (before reasoning pattern tracking)</li>
-                        <li>LLM calls via completion API (non-chat) without pattern analysis</li>
-                        <li>Missing llm_start events (correlation failure)</li>
-                    </ul>
-                    <details style="margin-top: 10px;">
-                        <summary style="cursor: pointer; color: #856404; font-weight: bold;">Show unknown events (first 10)</summary>
-                        <pre style="background: white; padding: 10px; border-radius: 4px; margin-top: 10px; font-size: 11px; max-height: 300px; overflow: auto;">${
-                            JSON.stringify(
-                                llmEventData
-                                    .filter(e => !e.reasoningPattern?.type || e.reasoningPattern?.type === 'unknown')
-                                    .slice(0, 10)
-                                    .map(e => ({
-                                        runId: e.runId,
-                                        agentId: e.agentId,
-                                        model: e.model,
-                                        graphNode: e.graphNode,
-                                        hasReasoningPattern: !!e.reasoningPattern,
-                                        reasoningPatternType: e.reasoningPattern?.type || 'MISSING',
-                                        inputTokens: e.inputTokens,
-                                        timestamp: e.timestamp?.toISOString?.() || e.timestamp,
-                                    })),
-                                null, 2
-                            )
-                        }</pre>
-                    </details>
-                </div>
-                ` : ''}
-            `;
-
-            container.innerHTML = html;
-
-            // Draw pie chart
-            if (totalCalls > 0) {
-                const pieData = Object.entries(patternCounts)
-                    .filter(([, count]) => count > 0)
-                    .map(([pattern, count]) => ({
-                        pattern,
-                        count,
-                        color: patternColors[pattern.replace('_with_thinking', '')] || '#CCCCCC'
-                    }));
-
-                const pieWidth = 200;
-                const pieHeight = 200;
-                const radius = Math.min(pieWidth, pieHeight) / 2;
-
-                const svg = d3.select('#patternPieChart')
-                    .append('svg')
-                    .attr('width', pieWidth)
-                    .attr('height', pieHeight)
-                    .append('g')
-                    .attr('transform', `translate(${pieWidth/2}, ${pieHeight/2})`);
-
-                const pie = d3.pie().value(d => d.count);
-                const arc = d3.arc().innerRadius(40).outerRadius(radius - 10);
-
-                svg.selectAll('path')
-                    .data(pie(pieData))
-                    .join('path')
-                    .attr('d', arc)
-                    .attr('fill', d => d.data.color)
-                    .attr('stroke', 'white')
-                    .attr('stroke-width', 2)
-                    .style('cursor', 'pointer')
-                    .on('mouseover', function(event, d) {
-                        d3.select(this).attr('opacity', 0.8);
-                        const tooltip = document.getElementById('tooltip');
-                        tooltip.style.display = 'block';
-                        tooltip.innerHTML = `
-                            <div class="tooltip-title">${d.data.pattern.replace(/_/g, ' ')}</div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Count:</span>
-                                <span>${d.data.count}</span>
-                            </div>
-                            <div class="tooltip-row">
-                                <span class="tooltip-label">Percentage:</span>
-                                <span>${(d.data.count / totalCalls * 100).toFixed(1)}%</span>
-                            </div>
-                        `;
-                        tooltip.style.left = event.pageX + 10 + 'px';
-                        tooltip.style.top = event.pageY + 10 + 'px';
-                    })
-                    .on('mouseout', function() {
-                        d3.select(this).attr('opacity', 1);
-                        document.getElementById('tooltip').style.display = 'none';
-                    });
-            }
-        }
-
-        // Render LangGraph node transitions
-        function renderGraphNodes() {
-            const container = document.getElementById('graphNodeContainer');
-            const statsContainer = document.getElementById('graphStatsContainer');
-
-            if (!graphNodeData || graphNodeData.length === 0) {
-                container.innerHTML = `
-                    <div style="text-align: center; padding: 40px 20px; color: #666;">
-                        <h4>No graph node data available</h4>
-                        <p>Graph node transitions will appear here when using LangGraph callbacks.</p>
-                    </div>
-                `;
-                statsContainer.innerHTML = '';
-                return;
-            }
-
-            // Calculate statistics
-            const nodeStarts = graphNodeData.filter(d => d.event === 'graph_node_start');
-            const nodeEnds = graphNodeData.filter(d => d.event === 'graph_node_end');
-            const uniqueNodes = new Set(graphNodeData.map(d => d.nodeName));
-            const uniqueAgents = new Set(graphNodeData.map(d => d.agentId));
-
-            // Count transitions per node
-            const nodeCounts = {};
-            nodeStarts.forEach(d => {
-                nodeCounts[d.nodeName] = (nodeCounts[d.nodeName] || 0) + 1;
-            });
-
-            // Render stats
-            statsContainer.innerHTML = `
-                <div class="stat-card success">
-                    <div class="stat-label">Total Node Transitions</div>
-                    <div class="stat-value">${nodeStarts.length}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Unique Nodes</div>
-                    <div class="stat-value">${uniqueNodes.size}</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-label">Active Agents</div>
-                    <div class="stat-value">${uniqueAgents.size}</div>
-                </div>
-            `;
-
-            // Build node transition table
-            const sortedNodes = Object.entries(nodeCounts).sort((a, b) => b[1] - a[1]);
-
-            const nodeColors = {
-                'agent': '#4facfe',
-                'tools': '#43e97b',
-                'file_tools': '#43e97b',
-                'run_subagent': '#fa709a',
-                '__start__': '#ffd700',
-                '__end__': '#ff6b6b'
-            };
-
-            let html = `
-                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px;">
-                    <div>
-                        <h4 style="margin-bottom: 10px;">Node Execution Counts</h4>
-                        <table style="width: 100%; border-collapse: collapse; background: white; border-radius: 6px; overflow: hidden;">
-                            <thead style="background: #f0f0f0;">
-                                <tr>
-                                    <th style="padding: 10px; text-align: left;">Node</th>
-                                    <th style="padding: 10px; text-align: center;">Count</th>
-                                    <th style="padding: 10px; text-align: left;">Bar</th>
-                                </tr>
-                            </thead>
-                            <tbody>
-                                ${sortedNodes.map(([node, count]) => {
-                                    const maxCount = sortedNodes[0][1];
-                                    const pct = (count / maxCount * 100).toFixed(0);
-                                    const color = nodeColors[node] || '#667eea';
-                                    return `
-                                        <tr style="border-bottom: 1px solid #eee;">
-                                            <td style="padding: 10px;">
-                                                <span style="display: inline-block; width: 12px; height: 12px; border-radius: 50%; background: ${color}; margin-right: 8px;"></span>
-                                                <strong>${node}</strong>
-                                            </td>
-                                            <td style="padding: 10px; text-align: center; font-weight: bold;">${count}</td>
-                                            <td style="padding: 10px;">
-                                                <div style="background: #f0f0f0; border-radius: 4px; height: 20px; width: 200px;">
-                                                    <div style="background: ${color}; height: 100%; width: ${pct}%; border-radius: 4px;"></div>
-                                                </div>
-                                            </td>
-                                        </tr>
-                                    `;
-                                }).join('')}
-                            </tbody>
-                        </table>
-                    </div>
-                    <div>
-                        <h4 style="margin-bottom: 10px;">Node Transition Timeline</h4>
-                        <svg id="graphTimelineSvg" style="width: 100%;"></svg>
-                    </div>
-                </div>
-            `;
-
-            container.innerHTML = html;
-
-            // Draw timeline visualization
-            const svg = d3.select('#graphTimelineSvg')
-                .attr('width', 600)
-                .attr('height', Math.max(200, uniqueNodes.size * 40 + 60));
-
-            const margin = { top: 20, right: 20, bottom: 30, left: 120 };
-            const width = 600 - margin.left - margin.right;
-            const height = svg.attr('height') - margin.top - margin.bottom;
-
-            const g = svg.append('g')
-                .attr('transform', `translate(${margin.left},${margin.top})`);
-
-            // Time scale
-            const timeExtent = d3.extent(graphNodeData, d => d.timestamp);
-            const xScale = d3.scaleTime()
-                .domain(timeExtent)
-                .range([0, width]);
-
-            // Node scale
-            const nodes = Array.from(uniqueNodes).sort();
-            const yScale = d3.scaleBand()
-                .domain(nodes)
-                .range([0, height])
-                .padding(0.2);
-
-            // Axes
-            g.append('g')
-                .attr('transform', `translate(0,${height})`)
-                .call(d3.axisBottom(xScale).ticks(5))
-                .selectAll('text')
-                .style('font-size', '10px');
-
-            g.append('g')
-                .call(d3.axisLeft(yScale))
-                .selectAll('text')
-                .style('font-size', '10px');
-
-            // Draw node start events as points
-            g.selectAll('.node-event')
-                .data(nodeStarts)
-                .join('circle')
-                .attr('cx', d => xScale(d.timestamp))
-                .attr('cy', d => yScale(d.nodeName) + yScale.bandwidth() / 2)
-                .attr('r', 6)
-                .attr('fill', d => nodeColors[d.nodeName] || '#667eea')
-                .attr('opacity', 0.8)
-                .attr('stroke', '#333')
-                .attr('stroke-width', 1)
-                .style('cursor', 'pointer')
-                .on('mouseover', function(event, d) {
-                    const tooltip = document.getElementById('tooltip');
-                    tooltip.style.display = 'block';
-                    tooltip.innerHTML = `
-                        <div class="tooltip-title">Graph Node: ${d.nodeName}</div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Agent:</span>
-                            <span>${d.agentId}</span>
-                        </div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Time:</span>
-                            <span>${d.timestamp.toLocaleTimeString()}</span>
-                        </div>
-                        <div class="tooltip-row">
-                            <span class="tooltip-label">Graph ID:</span>
-                            <span>${d.graphId || 'N/A'}</span>
-                        </div>
-                    `;
-                    tooltip.style.left = event.pageX + 10 + 'px';
-                    tooltip.style.top = event.pageY + 10 + 'px';
-                })
-                .on('mouseout', () => {
-                    document.getElementById('tooltip').style.display = 'none';
-                });
-        }
-
-        // Render all
-        function renderAll() {
-            renderStats();
-            renderTimeline();
-            renderLifespan();
-            renderReasoningPatterns();
-            renderGraphNodes();
-            renderAnalysis();
-            renderClustering();
-            attachClusteringListeners();
-            if (textBlockData.length > 0) {
-                renderTextAnalysis();
-            }
-            if (tokenData.length > 0) {
-                renderTokenTracking();
-            }
-        }
-
-        // Initial message
-        document.getElementById('timelineContainer').innerHTML = `
-            <div style="text-align: center; padding: 60px 20px; color: #666;">
-                <svg width="64" height="64" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="margin-bottom: 20px;">
-                    <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
-                    <polyline points="14 2 14 8 20 8"></polyline>
-                    <line x1="12" y1="18" x2="12" y2="12"></line>
-                    <line x1="9" y1="15" x2="15" y2="15"></line>
-                </svg>
-                <h3 style="margin-bottom: 10px;">No data loaded</h3>
-                <p>Please select a tool_calls.jsonl file to visualize</p>
-            </div>
-        `;
-    </script>
-</body>
-</html>
diff --git a/pyproject.toml b/pyproject.toml
index 12ce173..a096f1d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,13 +5,10 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "code-analysis-agent"
 version = "0.2.0"
-description = "Dependency-aware codebase analysis agent using LangGraph"
+description = "Dependency-aware codebase analysis agent using Burr"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "langgraph>=0.2.0",
-    "langchain-openai>=0.3.0",
-    "langchain-core>=0.3.0",
     "python-dotenv>=1.0.0",
     "burr[start]>=0.40.2",
 ]
diff --git a/uv.lock b/uv.lock
index 7140568..3bd88d2 100644
--- a/uv.lock
+++ b/uv.lock
@@ -289,9 +289,6 @@ version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "burr", extra = ["start"] },
-    { name = "langchain-core" },
-    { name = "langchain-openai" },
-    { name = "langgraph" },
     { name = "python-dotenv" },
 ]
 
@@ -311,9 +308,6 @@ dev = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'rag'", specifier = ">=0.30.0" },
     { name = "burr", extras = ["start"], specifier = ">=0.40.2" },
-    { name = "langchain-core", specifier = ">=0.3.0" },
-    { name = "langchain-openai", specifier = ">=0.3.0" },
-    { name = "langgraph", specifier = ">=0.2.0" },
     { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "streamlit", marker = "extra == 'rag'", specifier = ">=1.35.0" },
 ]
@@ -849,27 +843,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/e9/1f9ada30cef7b05e74bb06f52127e7a724976c225f46adb65c37b1dadfb6/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f00d94b281174144d6532a04b66a12cb866cbdc47c3af3bfe2973677f9861a", size = 349613, upload-time = "2026-04-10T14:28:40.066Z" },
 ]
 
-[[package]]
-name = "jsonpatch"
-version = "1.33"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jsonpointer" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699, upload-time = "2023-06-26T12:07:29.144Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/07/02e16ed01e04a374e644b575638ec7987ae846d25ad97bcc9945a3ee4b0e/jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade", size = 12898, upload-time = "2023-06-16T21:01:28.466Z" },
-]
-
-[[package]]
-name = "jsonpointer"
-version = "3.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" },
-]
-
 [[package]]
 name = "jsonschema"
 version = "4.26.0"
@@ -1021,115 +994,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" },
 ]
 
-[[package]]
-name = "langchain-core"
-version = "1.2.28"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jsonpatch" },
-    { name = "langsmith" },
-    { name = "packaging" },
-    { name = "pydantic" },
-    { name = "pyyaml" },
-    { name = "tenacity" },
-    { name = "typing-extensions" },
-    { name = "uuid-utils" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/a4/317a1a3ac1df33a64adb3670bf88bbe3b3d5baa274db6863a979db472897/langchain_core-1.2.28.tar.gz", hash = "sha256:271a3d8bd618f795fdeba112b0753980457fc90537c46a0c11998516a74dc2cb", size = 846119, upload-time = "2026-04-08T18:19:34.867Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/92/32f785f077c7e898da97064f113c73fbd9ad55d1e2169cf3a391b183dedb/langchain_core-1.2.28-py3-none-any.whl", hash = "sha256:80764232581eaf8057bcefa71dbf8adc1f6a28d257ebd8b95ba9b8b452e8c6ac", size = 508727, upload-time = "2026-04-08T18:19:32.823Z" },
-]
-
-[[package]]
-name = "langchain-openai"
-version = "1.1.12"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "langchain-core" },
-    { name = "openai" },
-    { name = "tiktoken" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/cc/fd/7dee16e882c4c1577d48db174d85aa3a0ee09ba61eb6a5d41650285ca80c/langchain_openai-1.1.12.tar.gz", hash = "sha256:ccf5ef02c896f6807b4d0e51aaf678a72ce81ae41201cae8d65e11eeff9ecb79", size = 1114119, upload-time = "2026-03-23T18:59:19.211Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/a6/68fb22e3604015e6f546fa1d3677d24378b482855ae74710cbf4aec44132/langchain_openai-1.1.12-py3-none-any.whl", hash = "sha256:da71ca3f2d18c16f7a2443cc306aa195ad2a07054335ac9b0626dcae02b6a0c5", size = 88487, upload-time = "2026-03-23T18:59:17.978Z" },
-]
-
-[[package]]
-name = "langgraph"
-version = "1.1.6"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "langchain-core" },
-    { name = "langgraph-checkpoint" },
-    { name = "langgraph-prebuilt" },
-    { name = "langgraph-sdk" },
-    { name = "pydantic" },
-    { name = "xxhash" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/e5/d3f72ead3c7f15769d5a9c07e373628f1fbaf6cbe7735694d7085859acf6/langgraph-1.1.6.tar.gz", hash = "sha256:1783f764b08a607e9f288dbcf6da61caeb0dd40b337e5c9fb8b412341fbc0b60", size = 549634, upload-time = "2026-04-03T19:01:32.561Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/e6/b36ecdb3ff4ba9a290708d514bae89ebbe2f554b6abbe4642acf3fddbe51/langgraph-1.1.6-py3-none-any.whl", hash = "sha256:fdbf5f54fa5a5a4c4b09b7b5e537f1b2fa283d2f0f610d3457ddeecb479458b9", size = 169755, upload-time = "2026-04-03T19:01:30.686Z" },
-]
-
-[[package]]
-name = "langgraph-checkpoint"
-version = "4.0.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "langchain-core" },
-    { name = "ormsgpack" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/44/a8df45d1e8b4637e29789fa8bae1db022c953cc7ac80093cfc52e923547e/langgraph_checkpoint-4.0.1.tar.gz", hash = "sha256:b433123735df11ade28829e40ce25b9be614930cd50245ff2af60629234befd9", size = 158135, upload-time = "2026-02-27T21:06:16.092Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/65/4c/09a4a0c42f5d2fc38d6c4d67884788eff7fd2cfdf367fdf7033de908b4c0/langgraph_checkpoint-4.0.1-py3-none-any.whl", hash = "sha256:e3adcd7a0e0166f3b48b8cf508ce0ea366e7420b5a73aa81289888727769b034", size = 50453, upload-time = "2026-02-27T21:06:14.293Z" },
-]
-
-[[package]]
-name = "langgraph-prebuilt"
-version = "1.0.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "langchain-core" },
-    { name = "langgraph-checkpoint" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/99/4c/06dac899f4945bedb0c3a1583c19484c2cc894114ea30d9a538dd270086e/langgraph_prebuilt-1.0.9.tar.gz", hash = "sha256:93de7512e9caade4b77ead92428f6215c521fdb71b8ffda8cd55f0ad814e64de", size = 165850, upload-time = "2026-04-03T14:06:37.721Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/a2/8368ac187b75e7f9d938ca075d34f116683f5cfc48d924029ee79aea147b/langgraph_prebuilt-1.0.9-py3-none-any.whl", hash = "sha256:776c8e3154a5aef5ad0e5bf3f263f2dcaab3983786cc20014b7f955d99d2d1b2", size = 35958, upload-time = "2026-04-03T14:06:36.58Z" },
-]
-
-[[package]]
-name = "langgraph-sdk"
-version = "0.3.13"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "httpx" },
-    { name = "orjson" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0e/db/77a45127dddcfea5e4256ba916182903e4c31dc4cfca305b8c386f0a9e53/langgraph_sdk-0.3.13.tar.gz", hash = "sha256:419ca5663eec3cec192ad194ac0647c0c826866b446073eb40f384f950986cd5", size = 196360, upload-time = "2026-04-07T20:34:18.766Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/ef/64d64e9f8eea47ce7b939aa6da6863b674c8d418647813c20111645fcc62/langgraph_sdk-0.3.13-py3-none-any.whl", hash = "sha256:aee09e345c90775f6de9d6f4c7b847cfc652e49055c27a2aed0d981af2af3bd0", size = 96668, upload-time = "2026-04-07T20:34:17.866Z" },
-]
-
-[[package]]
-name = "langsmith"
-version = "0.7.30"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "httpx" },
-    { name = "orjson", marker = "platform_python_implementation != 'PyPy'" },
-    { name = "packaging" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "requests-toolbelt" },
-    { name = "uuid-utils" },
-    { name = "xxhash" },
-    { name = "zstandard" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/46/e7/d27d952ce9824d684a3bb500a06541a2d55734bc4d849cdfcca2dfd4d93a/langsmith-0.7.30.tar.gz", hash = "sha256:d9df7ba5e42f818b63bda78776c8f2fc853388be3ae77b117e5d183a149321a2", size = 1106040, upload-time = "2026-04-09T21:12:01.892Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/37/19/96250cf58070c5563446651b03bb76c2eb5afbf08e754840ab639532d8c6/langsmith-0.7.30-py3-none-any.whl", hash = "sha256:43dd9f8d290e4d406606d6cc0bd62f5d1050963f05fe0ab6ffe50acf41f2f55a", size = 372682, upload-time = "2026-04-09T21:12:00.481Z" },
-]
-
 [[package]]
 name = "loguru"
 version = "0.7.3"
@@ -1575,143 +1439,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/55/22/41fb05f1dc5fda2c468e05a41814c20859016c85117b66c8a257cae814f6/opentelemetry_semantic_conventions_ai-0.5.1-py3-none-any.whl", hash = "sha256:25aeb22bd261543b4898a73824026d96770e5351209c7d07a0b1314762b1f6e4", size = 11250, upload-time = "2026-03-26T14:20:37.108Z" },
 ]
 
-[[package]]
-name = "orjson"
-version = "3.11.8"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/1b/2024d06792d0779f9dbc51531b61c24f76c75b9f4ce05e6f3377a1814cea/orjson-3.11.8.tar.gz", hash = "sha256:96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e", size = 5603832, upload-time = "2026-03-31T16:16:27.878Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2f/90/5d81f61fe3e4270da80c71442864c091cee3003cc8984c75f413fe742a07/orjson-3.11.8-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:e6693ff90018600c72fd18d3d22fa438be26076cd3c823da5f63f7bab28c11cb", size = 229663, upload-time = "2026-03-31T16:14:30.708Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/ef/85e06b0eb11de6fb424120fd5788a07035bd4c5e6bb7841ae9972a0526d1/orjson-3.11.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93de06bc920854552493c81f1f729fab7213b7db4b8195355db5fda02c7d1363", size = 132321, upload-time = "2026-03-31T16:14:32.317Z" },
-    { url = "https://files.pythonhosted.org/packages/86/71/089338ee51b3132f050db0864a7df9bdd5e94c2a03820ab8a91e8f655618/orjson-3.11.8-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fe0b8c83e0f36247fc9431ce5425a5d95f9b3a689133d494831bdbd6f0bceb13", size = 130658, upload-time = "2026-03-31T16:14:33.935Z" },
-    { url = "https://files.pythonhosted.org/packages/10/0d/f39d8802345d0ad65f7fd4374b29b9b59f98656dc30f21ca5c773265b2f0/orjson-3.11.8-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:97d823831105c01f6c8029faf297633dbeb30271892bd430e9c24ceae3734744", size = 135708, upload-time = "2026-03-31T16:14:35.224Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/b5/40aae576b3473511696dcffea84fde638b2b64774eb4dcb8b2c262729f8a/orjson-3.11.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c60c0423f15abb6cf78f56dff00168a1b582f7a1c23f114036e2bfc697814d5f", size = 147047, upload-time = "2026-03-31T16:14:36.489Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/f0/778a84458d1fdaa634b2e572e51ce0b354232f580b2327e1f00a8d88c38c/orjson-3.11.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:01928d0476b216ad2201823b0a74000440360cef4fed1912d297b8d84718f277", size = 133072, upload-time = "2026-03-31T16:14:37.715Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/d3/1bbf2fc3ffcc4b829ade554b574af68cec898c9b5ad6420a923c75a073d3/orjson-3.11.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a4a639049c44d36a6d1ae0f4a94b271605c745aee5647fa8ffaabcdc01b69a6", size = 133867, upload-time = "2026-03-31T16:14:39.356Z" },
-    { url = "https://files.pythonhosted.org/packages/08/94/6413da22edc99a69a8d0c2e83bf42973b8aa94d83ef52a6d39ac85da00bc/orjson-3.11.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3222adff1e1ff0dce93c16146b93063a7793de6c43d52309ae321234cdaf0f4d", size = 142268, upload-time = "2026-03-31T16:14:40.972Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/5f/aa5dbaa6136d7ba55f5461ac2e885efc6e6349424a428927fd46d68f4396/orjson-3.11.8-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:3223665349bbfb68da234acd9846955b1a0808cbe5520ff634bf253a4407009b", size = 424008, upload-time = "2026-03-31T16:14:42.637Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/aa/2c1962d108c7fe5e27aa03a354b378caf56d8eafdef15fd83dec081ce45a/orjson-3.11.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:61c9d357a59465736022d5d9ba06687afb7611dfb581a9d2129b77a6fcf78e59", size = 147942, upload-time = "2026-03-31T16:14:44.256Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/65f404f4c47eb1b0b4476f03ec838cac0c4aa933920ff81e5dda4dee14e7/orjson-3.11.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:58fb9b17b4472c7b1dcf1a54583629e62e23779b2331052f09a9249edf81675b", size = 136640, upload-time = "2026-03-31T16:14:45.884Z" },
-    { url = "https://files.pythonhosted.org/packages/90/5f/7b784aea98bdb125a2f2da7c27d6c2d2f6d943d96ef0278bae596d563f85/orjson-3.11.8-cp310-cp310-win32.whl", hash = "sha256:b43dc2a391981d36c42fa57747a49dae793ef1d2e43898b197925b5534abd10a", size = 132066, upload-time = "2026-03-31T16:14:47.397Z" },
-    { url = "https://files.pythonhosted.org/packages/92/ec/2e284af8d6c9478df5ef938917743f61d68f4c70d17f1b6e82f7e3b8dba1/orjson-3.11.8-cp310-cp310-win_amd64.whl", hash = "sha256:c98121237fea2f679480765abd566f7713185897f35c9e6c2add7e3a9900eb61", size = 127609, upload-time = "2026-03-31T16:14:48.78Z" },
-    { url = "https://files.pythonhosted.org/packages/67/41/5aa7fa3b0f4dc6b47dcafc3cea909299c37e40e9972feabc8b6a74e2730d/orjson-3.11.8-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:003646067cc48b7fcab2ae0c562491c9b5d2cbd43f1e5f16d98fd118c5522d34", size = 229229, upload-time = "2026-03-31T16:14:50.424Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/d7/57e7f2458e0a2c41694f39fc830030a13053a84f837a5b73423dca1f0938/orjson-3.11.8-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:ed193ce51d77a3830cad399a529cd4ef029968761f43ddc549e1bc62b40d88f8", size = 128871, upload-time = "2026-03-31T16:14:51.888Z" },
-    { url = "https://files.pythonhosted.org/packages/53/4a/e0fdb9430983e6c46e0299559275025075568aad5d21dd606faee3703924/orjson-3.11.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f30491bc4f862aa15744b9738517454f1e46e56c972a2be87d70d727d5b2a8f8", size = 132104, upload-time = "2026-03-31T16:14:53.142Z" },
-    { url = "https://files.pythonhosted.org/packages/08/4a/2025a60ff3f5c8522060cda46612d9b1efa653de66ed2908591d8d82f22d/orjson-3.11.8-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6eda5b8b6be91d3f26efb7dc6e5e68ee805bc5617f65a328587b35255f138bf4", size = 130483, upload-time = "2026-03-31T16:14:54.605Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/3c/b9cde05bdc7b2385c66014e0620627da638d3d04e4954416ab48c31196c5/orjson-3.11.8-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee8db7bfb6fe03581bbab54d7c4124a6dd6a7f4273a38f7267197890f094675f", size = 135481, upload-time = "2026-03-31T16:14:55.901Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/f2/a8238e7734de7cb589fed319857a8025d509c89dc52fdcc88f39c6d03d5a/orjson-3.11.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5d8b5231de76c528a46b57010bbd83fb51e056aa0220a372fd5065e978406f1c", size = 146819, upload-time = "2026-03-31T16:14:57.548Z" },
-    { url = "https://files.pythonhosted.org/packages/db/10/dbf1e2a3cafea673b1b4350e371877b759060d6018a998643b7040e5de48/orjson-3.11.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:58a4a208a6fbfdb7a7327b8f201c6014f189f721fd55d047cafc4157af1bc62a", size = 132846, upload-time = "2026-03-31T16:14:58.91Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/fc/55e667ec9c85694038fcff00573d221b085d50777368ee3d77f38668bf3c/orjson-3.11.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f8952d6d2505c003e8f0224ff7858d341fa4e33fef82b91c4ff0ef070f2393c", size = 133580, upload-time = "2026-03-31T16:15:00.519Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a6/c08c589a9aad0cb46c4831d17de212a2b6901f9d976814321ff8e69e8785/orjson-3.11.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0022bb50f90da04b009ce32c512dc1885910daa7cb10b7b0cba4505b16db82a8", size = 142042, upload-time = "2026-03-31T16:15:01.906Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/cc/2f78ea241d52b717d2efc38878615fe80425bf2beb6e68c984dde257a766/orjson-3.11.8-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ff51f9d657d1afb6f410cb435792ce4e1fe427aab23d2fcd727a2876e21d4cb6", size = 423845, upload-time = "2026-03-31T16:15:03.703Z" },
-    { url = "https://files.pythonhosted.org/packages/70/07/c17dcf05dd8045457538428a983bf1f1127928df5bf328cb24d2b7cddacb/orjson-3.11.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6dbe9a97bdb4d8d9d5367b52a7c32549bba70b2739c58ef74a6964a6d05ae054", size = 147729, upload-time = "2026-03-31T16:15:05.203Z" },
-    { url = "https://files.pythonhosted.org/packages/90/6c/0fb6e8a24e682e0958d71711ae6f39110e4b9cd8cab1357e2a89cb8e1951/orjson-3.11.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5c370674ebabe16c6ccac33ff80c62bf8a6e59439f5e9d40c1f5ab8fd2215b7", size = 136425, upload-time = "2026-03-31T16:15:07.052Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/35/4d3cc3a3d616035beb51b24a09bb872942dc452cf2df0c1d11ab35046d9f/orjson-3.11.8-cp311-cp311-win32.whl", hash = "sha256:0e32f7154299f42ae66f13488963269e5eccb8d588a65bc839ed986919fc9fac", size = 131870, upload-time = "2026-03-31T16:15:08.678Z" },
-    { url = "https://files.pythonhosted.org/packages/13/26/9fe70f81d16b702f8c3a775e8731b50ad91d22dacd14c7599b60a0941cd1/orjson-3.11.8-cp311-cp311-win_amd64.whl", hash = "sha256:25e0c672a2e32348d2eb33057b41e754091f2835f87222e4675b796b92264f06", size = 127440, upload-time = "2026-03-31T16:15:09.994Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/c6/b038339f4145efd2859c1ca53097a52c0bb9cbdd24f947ebe146da1ad067/orjson-3.11.8-cp311-cp311-win_arm64.whl", hash = "sha256:9185589c1f2a944c17e26c9925dcdbc2df061cc4a145395c57f0c51f9b5dbfcd", size = 127399, upload-time = "2026-03-31T16:15:11.412Z" },
-    { url = "https://files.pythonhosted.org/packages/01/f6/8d58b32ab32d9215973a1688aebd098252ee8af1766c0e4e36e7831f0295/orjson-3.11.8-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1cd0b77e77c95758f8e1100139844e99f3ccc87e71e6fc8e1c027e55807c549f", size = 229233, upload-time = "2026-03-31T16:15:12.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/8b/2ffe35e71f6b92622e8ea4607bf33ecf7dfb51b3619dcfabfd36cbe2d0a5/orjson-3.11.8-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:6a3d159d5ffa0e3961f353c4b036540996bf8b9697ccc38261c0eac1fd3347a6", size = 128772, upload-time = "2026-03-31T16:15:14.237Z" },
-    { url = "https://files.pythonhosted.org/packages/27/d2/1f8682ae50d5c6897a563cb96bc106da8c9cb5b7b6e81a52e4cc086679b9/orjson-3.11.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76070a76e9c5ae661e2d9848f216980d8d533e0f8143e6ed462807b242e3c5e8", size = 131946, upload-time = "2026-03-31T16:15:15.607Z" },
-    { url = "https://files.pythonhosted.org/packages/52/4b/5500f76f0eece84226e0689cb48dcde081104c2fa6e2483d17ca13685ffb/orjson-3.11.8-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:54153d21520a71a4c82a0dbb4523e468941d549d221dc173de0f019678cf3813", size = 130368, upload-time = "2026-03-31T16:15:17.066Z" },
-    { url = "https://files.pythonhosted.org/packages/da/4e/58b927e08fbe9840e6c920d9e299b051ea667463b1f39a56e668669f8508/orjson-3.11.8-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:469ac2125611b7c5741a0b3798cd9e5786cbad6345f9f400c77212be89563bec", size = 135540, upload-time = "2026-03-31T16:15:18.404Z" },
-    { url = "https://files.pythonhosted.org/packages/56/7c/ba7cb871cba1bcd5cd02ee34f98d894c6cea96353ad87466e5aef2429c60/orjson-3.11.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:14778ffd0f6896aa613951a7fbf4690229aa7a543cb2bfbe9f358e08aafa9546", size = 146877, upload-time = "2026-03-31T16:15:19.833Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/5d/eb9c25fc1386696c6a342cd361c306452c75e0b55e86ad602dd4827a7fd7/orjson-3.11.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea56a955056a6d6c550cf18b3348656a9d9a4f02e2d0c02cabf3c73f1055d506", size = 132837, upload-time = "2026-03-31T16:15:21.282Z" },
-    { url = "https://files.pythonhosted.org/packages/37/87/5ddeb7fc1fbd9004aeccab08426f34c81a5b4c25c7061281862b015fce2b/orjson-3.11.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:53a0f57e59a530d18a142f4d4ba6dfc708dc5fdedce45e98ff06b44930a2a48f", size = 133624, upload-time = "2026-03-31T16:15:22.641Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/90048793db94ee4b2fcec4ac8e5ddb077367637d6650be896b3494b79bb7/orjson-3.11.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9b48e274f8824567d74e2158199e269597edf00823a1b12b63d48462bbf5123e", size = 141904, upload-time = "2026-03-31T16:15:24.435Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cf/eb284847487821a5d415e54149a6449ba9bfc5872ce63ab7be41b8ec401c/orjson-3.11.8-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:3f262401086a3960586af06c054609365e98407151f5ea24a62893a40d80dbbb", size = 423742, upload-time = "2026-03-31T16:15:26.155Z" },
-    { url = "https://files.pythonhosted.org/packages/44/09/e12423d327071c851c13e76936f144a96adacfc037394dec35ac3fc8d1e8/orjson-3.11.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e8c6218b614badf8e229b697865df4301afa74b791b6c9ade01d19a9953a942", size = 147806, upload-time = "2026-03-31T16:15:27.909Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/6d/37c2589ba864e582ffe7611643314785c6afb1f83c701654ef05daa8fcc7/orjson-3.11.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:093d489fa039ddade2db541097dbb484999fcc65fc2b0ff9819141e2ab364f25", size = 136485, upload-time = "2026-03-31T16:15:29.749Z" },
-    { url = "https://files.pythonhosted.org/packages/be/c9/135194a02ab76b04ed9a10f68624b7ebd238bbe55548878b11ff15a0f352/orjson-3.11.8-cp312-cp312-win32.whl", hash = "sha256:e0950ed1bcb9893f4293fd5c5a7ee10934fbf82c4101c70be360db23ce24b7d2", size = 131966, upload-time = "2026-03-31T16:15:31.687Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/9a/9796f8fbe3cf30ce9cb696748dbb535e5c87be4bf4fe2e9ca498ef1fa8cf/orjson-3.11.8-cp312-cp312-win_amd64.whl", hash = "sha256:3cf17c141617b88ced4536b2135c552490f07799f6ad565948ea07bef0dcb9a6", size = 127441, upload-time = "2026-03-31T16:15:33.333Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/47/5aaf54524a7a4a0dd09dd778f3fa65dd2108290615b652e23d944152bc8e/orjson-3.11.8-cp312-cp312-win_arm64.whl", hash = "sha256:48854463b0572cc87dac7d981aa72ed8bf6deedc0511853dc76b8bbd5482d36d", size = 127364, upload-time = "2026-03-31T16:15:34.748Z" },
-    { url = "https://files.pythonhosted.org/packages/66/7f/95fba509bb2305fab0073558f1e8c3a2ec4b2afe58ed9fcb7d3b8beafe94/orjson-3.11.8-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:3f23426851d98478c8970da5991f84784a76682213cd50eb73a1da56b95239dc", size = 229180, upload-time = "2026-03-31T16:15:36.426Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/9d/b237215c743ca073697d759b5503abd2cb8a0d7b9c9e21f524bcf176ab66/orjson-3.11.8-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:ebaed4cef74a045b83e23537b52ef19a367c7e3f536751e355a2a394f8648559", size = 128754, upload-time = "2026-03-31T16:15:38.049Z" },
-    { url = "https://files.pythonhosted.org/packages/42/3d/27d65b6d11e63f133781425f132807aef793ed25075fec686fc8e46dd528/orjson-3.11.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97c8f5d3b62380b70c36ffacb2a356b7c6becec86099b177f73851ba095ef623", size = 131877, upload-time = "2026-03-31T16:15:39.484Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/cc/faee30cd8f00421999e40ef0eba7332e3a625ce91a58200a2f52c7fef235/orjson-3.11.8-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:436c4922968a619fb7fef1ccd4b8b3a76c13b67d607073914d675026e911a65c", size = 130361, upload-time = "2026-03-31T16:15:41.274Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/bb/a6c55896197f97b6d4b4e7c7fd77e7235517c34f5d6ad5aadd43c54c6d7c/orjson-3.11.8-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1ab359aff0436d80bfe8a23b46b5fea69f1e18aaf1760a709b4787f1318b317f", size = 135521, upload-time = "2026-03-31T16:15:42.758Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/7c/ca3a3525aa32ff636ebb1778e77e3587b016ab2edb1b618b36ba96f8f2c0/orjson-3.11.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f89b6d0b3a8d81e1929d3ab3d92bbc225688bd80a770c49432543928fe09ac55", size = 146862, upload-time = "2026-03-31T16:15:44.341Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/0c/18a9d7f18b5edd37344d1fd5be17e94dc652c67826ab749c6e5948a78112/orjson-3.11.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:29c009e7a2ca9ad0ed1376ce20dd692146a5d9fe4310848904b6b4fee5c5c137", size = 132847, upload-time = "2026-03-31T16:15:46.368Z" },
-    { url = "https://files.pythonhosted.org/packages/23/91/7e722f352ad67ca573cee44de2a58fb810d0f4eb4e33276c6a557979fd8a/orjson-3.11.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:705b895b781b3e395c067129d8551655642dfe9437273211d5404e87ac752b53", size = 133637, upload-time = "2026-03-31T16:15:48.123Z" },
-    { url = "https://files.pythonhosted.org/packages/af/04/32845ce13ac5bd1046ddb02ac9432ba856cc35f6d74dde95864fe0ad5523/orjson-3.11.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:88006eda83858a9fdf73985ce3804e885c2befb2f506c9a3723cdeb5a2880e3e", size = 141906, upload-time = "2026-03-31T16:15:49.626Z" },
-    { url = "https://files.pythonhosted.org/packages/02/5e/c551387ddf2d7106d9039369862245c85738b828844d13b99ccb8d61fd06/orjson-3.11.8-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:55120759e61309af7fcf9e961c6f6af3dde5921cdb3ee863ef63fd9db126cae6", size = 423722, upload-time = "2026-03-31T16:15:51.176Z" },
-    { url = "https://files.pythonhosted.org/packages/00/a3/ecfe62434096f8a794d4976728cb59bcfc4a643977f21c2040545d37eb4c/orjson-3.11.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:98bdc6cb889d19bed01de46e67574a2eab61f5cc6b768ed50e8ac68e9d6ffab6", size = 147801, upload-time = "2026-03-31T16:15:52.939Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6d/0dce10b9f6643fdc59d99333871a38fa5a769d8e2fc34a18e5d2bfdee900/orjson-3.11.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:708c95f925a43ab9f34625e45dcdadf09ec8a6e7b664a938f2f8d5650f6c090b", size = 136460, upload-time = "2026-03-31T16:15:54.431Z" },
-    { url = "https://files.pythonhosted.org/packages/01/d6/6dde4f31842d87099238f1f07b459d24edc1a774d20687187443ab044191/orjson-3.11.8-cp313-cp313-win32.whl", hash = "sha256:01c4e5a6695dc09098f2e6468a251bc4671c50922d4d745aff1a0a33a0cf5b8d", size = 131956, upload-time = "2026-03-31T16:15:56.081Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/f9/4e494a56e013db957fb77186b818b916d4695b8fa2aa612364974160e91b/orjson-3.11.8-cp313-cp313-win_amd64.whl", hash = "sha256:c154a35dd1330707450bb4d4e7dd1f17fa6f42267a40c1e8a1daa5e13719b4b8", size = 127410, upload-time = "2026-03-31T16:15:57.54Z" },
-    { url = "https://files.pythonhosted.org/packages/57/7f/803203d00d6edb6e9e7eef421d4e1adbb5ea973e40b3533f3cfd9aeb374e/orjson-3.11.8-cp313-cp313-win_arm64.whl", hash = "sha256:4861bde57f4d253ab041e374f44023460e60e71efaa121f3c5f0ed457c3a701e", size = 127338, upload-time = "2026-03-31T16:15:59.106Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/35/b01910c3d6b85dc882442afe5060cbf719c7d1fc85749294beda23d17873/orjson-3.11.8-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:ec795530a73c269a55130498842aaa762e4a939f6ce481a7e986eeaa790e9da4", size = 229171, upload-time = "2026-03-31T16:16:00.651Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/56/c9ec97bd11240abef39b9e5d99a15462809c45f677420fd148a6c5e6295e/orjson-3.11.8-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c492a0e011c0f9066e9ceaa896fbc5b068c54d365fea5f3444b697ee01bc8625", size = 128746, upload-time = "2026-03-31T16:16:02.673Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/e4/66d4f30a90de45e2f0cbd9623588e8ae71eef7679dbe2ae954ed6d66a41f/orjson-3.11.8-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:883206d55b1bd5f5679ad5e6ddd3d1a5e3cac5190482927fdb8c78fb699193b5", size = 131867, upload-time = "2026-03-31T16:16:04.342Z" },
-    { url = "https://files.pythonhosted.org/packages/19/30/2a645fc9286b928675e43fa2a3a16fb7b6764aa78cc719dc82141e00f30b/orjson-3.11.8-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5774c1fdcc98b2259800b683b19599c133baeb11d60033e2095fd9d4667b82db", size = 124664, upload-time = "2026-03-31T16:16:05.837Z" },
-    { url = "https://files.pythonhosted.org/packages/db/44/77b9a86d84a28d52ba3316d77737f6514e17118119ade3f91b639e859029/orjson-3.11.8-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ac7381c83dd3d4a6347e6635950aa448f54e7b8406a27c7ecb4a37e9f1ae08b", size = 129701, upload-time = "2026-03-31T16:16:07.407Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/ea/eff3d9bfe47e9bc6969c9181c58d9f71237f923f9c86a2d2f490cd898c82/orjson-3.11.8-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:14439063aebcb92401c11afc68ee4e407258d2752e62d748b6942dad20d2a70d", size = 141202, upload-time = "2026-03-31T16:16:09.48Z" },
-    { url = "https://files.pythonhosted.org/packages/52/c8/90d4b4c60c84d62068d0cf9e4d8f0a4e05e76971d133ac0c60d818d4db20/orjson-3.11.8-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fa72e71977bff96567b0f500fc5bfd2fdf915f34052c782a4c6ebbdaa97aa858", size = 127194, upload-time = "2026-03-31T16:16:11.02Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/c7/ea9e08d1f0ba981adffb629811148b44774d935171e7b3d780ae43c4c254/orjson-3.11.8-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7679bc2f01bb0d219758f1a5f87bb7c8a81c0a186824a393b366876b4948e14f", size = 133639, upload-time = "2026-03-31T16:16:13.434Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/8c/ddbbfd6ba59453c8fc7fe1d0e5983895864e264c37481b2a791db635f046/orjson-3.11.8-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:14f7b8fcb35ef403b42fa5ecfa4ed032332a91f3dc7368fbce4184d59e1eae0d", size = 141914, upload-time = "2026-03-31T16:16:14.955Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/31/dbfbefec9df060d34ef4962cd0afcb6fa7a9ec65884cb78f04a7859526c3/orjson-3.11.8-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:c2bdf7b2facc80b5e34f48a2d557727d5c5c57a8a450de122ae81fa26a81c1bc", size = 423800, upload-time = "2026-03-31T16:16:16.594Z" },
-    { url = "https://files.pythonhosted.org/packages/87/cf/f74e9ae9803d4ab46b163494adba636c6d7ea955af5cc23b8aaa94cfd528/orjson-3.11.8-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ccd7ba1b0605813a0715171d39ec4c314cb97a9c85893c2c5c0c3a3729df38bf", size = 147837, upload-time = "2026-03-31T16:16:18.585Z" },
-    { url = "https://files.pythonhosted.org/packages/64/e6/9214f017b5db85e84e68602792f742e5dc5249e963503d1b356bee611e01/orjson-3.11.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cdbc8c9c02463fef4d3c53a9ba3336d05496ec8e1f1c53326a1e4acc11f5c600", size = 136441, upload-time = "2026-03-31T16:16:20.151Z" },
-    { url = "https://files.pythonhosted.org/packages/24/dd/3590348818f58f837a75fb969b04cdf187ae197e14d60b5e5a794a38b79d/orjson-3.11.8-cp314-cp314-win32.whl", hash = "sha256:0b57f67710a8cd459e4e54eb96d5f77f3624eba0c661ba19a525807e42eccade", size = 131983, upload-time = "2026-03-31T16:16:21.823Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/0f/b6cb692116e05d058f31ceee819c70f097fa9167c82f67fabe7516289abc/orjson-3.11.8-cp314-cp314-win_amd64.whl", hash = "sha256:735e2262363dcbe05c35e3a8869898022af78f89dde9e256924dc02e99fe69ca", size = 127396, upload-time = "2026-03-31T16:16:23.685Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/d1/facb5b5051fabb0ef9d26c6544d87ef19a939a9a001198655d0d891062dd/orjson-3.11.8-cp314-cp314-win_arm64.whl", hash = "sha256:6ccdea2c213cf9f3d9490cbd5d427693c870753df41e6cb375bd79bcbafc8817", size = 127330, upload-time = "2026-03-31T16:16:25.496Z" },
-]
-
-[[package]]
-name = "ormsgpack"
-version = "1.12.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/12/0c/f1761e21486942ab9bb6feaebc610fa074f7c5e496e6962dea5873348077/ormsgpack-1.12.2.tar.gz", hash = "sha256:944a2233640273bee67521795a73cf1e959538e0dfb7ac635505010455e53b33", size = 39031, upload-time = "2026-01-18T20:55:28.023Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/93/fa/a91f70829ebccf6387c4946e0a1a109f6ba0d6a28d65f628bedfad94b890/ormsgpack-1.12.2-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:c1429217f8f4d7fcb053523bbbac6bed5e981af0b85ba616e6df7cce53c19657", size = 378262, upload-time = "2026-01-18T20:55:22.284Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/62/3698a9a0c487252b5c6a91926e5654e79e665708ea61f67a8bdeceb022bf/ormsgpack-1.12.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f13034dc6c84a6280c6c33db7ac420253852ea233fc3ee27c8875f8dd651163", size = 203034, upload-time = "2026-01-18T20:55:53.324Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3a/f716f64edc4aec2744e817660b317e2f9bb8de372338a95a96198efa1ac1/ormsgpack-1.12.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:59f5da97000c12bc2d50e988bdc8576b21f6ab4e608489879d35b2c07a8ab51a", size = 210538, upload-time = "2026-01-18T20:55:20.097Z" },
-    { url = "https://files.pythonhosted.org/packages/72/30/a436be9ce27d693d4e19fa94900028067133779f09fc45776db3f689c822/ormsgpack-1.12.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e4459c3f27066beadb2b81ea48a076a417aafffff7df1d3c11c519190ed44f2", size = 212401, upload-time = "2026-01-18T20:55:46.447Z" },
-    { url = "https://files.pythonhosted.org/packages/10/c5/cde98300fd33fee84ca71de4751b19aeeca675f0cf3c0ec4b043f40f3b76/ormsgpack-1.12.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a1c460655d7288407ffa09065e322a7231997c0d62ce914bf3a96ad2dc6dedd", size = 387080, upload-time = "2026-01-18T20:56:00.884Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/31/30bf445ef827546747c10889dd254b3d84f92b591300efe4979d792f4c41/ormsgpack-1.12.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:458e4568be13d311ef7d8877275e7ccbe06c0e01b39baaac874caaa0f46d826c", size = 482346, upload-time = "2026-01-18T20:55:39.831Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/f5/e1745ddf4fa246c921b5ca253636c4c700ff768d78032f79171289159f6e/ormsgpack-1.12.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8cde5eaa6c6cbc8622db71e4a23de56828e3d876aeb6460ffbcb5b8aff91093b", size = 425178, upload-time = "2026-01-18T20:55:27.106Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/a2/e6532ed7716aed03dede8df2d0d0d4150710c2122647d94b474147ccd891/ormsgpack-1.12.2-cp310-cp310-win_amd64.whl", hash = "sha256:dc7a33be14c347893edbb1ceda89afbf14c467d593a5ee92c11de4f1666b4d4f", size = 117183, upload-time = "2026-01-18T20:55:55.52Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/08/8b68f24b18e69d92238aa8f258218e6dfeacf4381d9d07ab8df303f524a9/ormsgpack-1.12.2-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:bd5f4bf04c37888e864f08e740c5a573c4017f6fd6e99fa944c5c935fabf2dd9", size = 378266, upload-time = "2026-01-18T20:55:59.876Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/24/29fc13044ecb7c153523ae0a1972269fcd613650d1fa1a9cec1044c6b666/ormsgpack-1.12.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:34d5b28b3570e9fed9a5a76528fc7230c3c76333bc214798958e58e9b79cc18a", size = 203035, upload-time = "2026-01-18T20:55:30.59Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/c2/00169fb25dd8f9213f5e8a549dfb73e4d592009ebc85fbbcd3e1dcac575b/ormsgpack-1.12.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3708693412c28f3538fb5a65da93787b6bbab3484f6bc6e935bfb77a62400ae5", size = 210539, upload-time = "2026-01-18T20:55:48.569Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/33/543627f323ff3c73091f51d6a20db28a1a33531af30873ea90c5ac95a9b5/ormsgpack-1.12.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:43013a3f3e2e902e1d05e72c0f1aeb5bedbb8e09240b51e26792a3c89267e181", size = 212401, upload-time = "2026-01-18T20:56:10.101Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/5d/f70e2c3da414f46186659d24745483757bcc9adccb481a6eb93e2b729301/ormsgpack-1.12.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7c8b1667a72cbba74f0ae7ecf3105a5e01304620ed14528b2cb4320679d2869b", size = 387082, upload-time = "2026-01-18T20:56:12.047Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/d6/06e8dc920c7903e051f30934d874d4afccc9bb1c09dcaf0bc03a7de4b343/ormsgpack-1.12.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:df6961442140193e517303d0b5d7bc2e20e69a879c2d774316125350c4a76b92", size = 482346, upload-time = "2026-01-18T20:56:05.152Z" },
-    { url = "https://files.pythonhosted.org/packages/66/c4/f337ac0905eed9c393ef990c54565cd33644918e0a8031fe48c098c71dbf/ormsgpack-1.12.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c6a4c34ddef109647c769d69be65fa1de7a6022b02ad45546a69b3216573eb4a", size = 425181, upload-time = "2026-01-18T20:55:37.83Z" },
-    { url = "https://files.pythonhosted.org/packages/78/29/6d5758fabef3babdf4bbbc453738cc7de9cd3334e4c38dd5737e27b85653/ormsgpack-1.12.2-cp311-cp311-win_amd64.whl", hash = "sha256:73670ed0375ecc303858e3613f407628dd1fca18fe6ac57b7b7ce66cc7bb006c", size = 117182, upload-time = "2026-01-18T20:55:31.472Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/57/17a15549233c37e7fd054c48fe9207492e06b026dbd872b826a0b5f833b6/ormsgpack-1.12.2-cp311-cp311-win_arm64.whl", hash = "sha256:c2be829954434e33601ae5da328cccce3266b098927ca7a30246a0baec2ce7bd", size = 111464, upload-time = "2026-01-18T20:55:38.811Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/36/16c4b1921c308a92cef3bf6663226ae283395aa0ff6e154f925c32e91ff5/ormsgpack-1.12.2-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:7a29d09b64b9694b588ff2f80e9826bdceb3a2b91523c5beae1fab27d5c940e7", size = 378618, upload-time = "2026-01-18T20:55:50.835Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/68/468de634079615abf66ed13bb5c34ff71da237213f29294363beeeca5306/ormsgpack-1.12.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b39e629fd2e1c5b2f46f99778450b59454d1f901bc507963168985e79f09c5d", size = 203186, upload-time = "2026-01-18T20:56:11.163Z" },
-    { url = "https://files.pythonhosted.org/packages/73/a9/d756e01961442688b7939bacd87ce13bfad7d26ce24f910f6028178b2cc8/ormsgpack-1.12.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:958dcb270d30a7cb633a45ee62b9444433fa571a752d2ca484efdac07480876e", size = 210738, upload-time = "2026-01-18T20:56:09.181Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/ba/795b1036888542c9113269a3f5690ab53dd2258c6fb17676ac4bd44fcf94/ormsgpack-1.12.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58d379d72b6c5e964851c77cfedfb386e474adee4fd39791c2c5d9efb53505cc", size = 212569, upload-time = "2026-01-18T20:56:06.135Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/aa/bff73c57497b9e0cba8837c7e4bcab584b1a6dbc91a5dd5526784a5030c8/ormsgpack-1.12.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8463a3fc5f09832e67bdb0e2fda6d518dc4281b133166146a67f54c08496442e", size = 387166, upload-time = "2026-01-18T20:55:36.738Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/cf/f8283cba44bcb7b14f97b6274d449db276b3a86589bdb363169b51bc12de/ormsgpack-1.12.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:eddffb77eff0bad4e67547d67a130604e7e2dfbb7b0cde0796045be4090f35c6", size = 482498, upload-time = "2026-01-18T20:55:29.626Z" },
-    { url = "https://files.pythonhosted.org/packages/05/be/71e37b852d723dfcbe952ad04178c030df60d6b78eba26bfd14c9a40575e/ormsgpack-1.12.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fcd55e5f6ba0dbce624942adf9f152062135f991a0126064889f68eb850de0dd", size = 425518, upload-time = "2026-01-18T20:55:49.556Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/0c/9803aa883d18c7ef197213cd2cbf73ba76472a11fe100fb7dab2884edf48/ormsgpack-1.12.2-cp312-cp312-win_amd64.whl", hash = "sha256:d024b40828f1dde5654faebd0d824f9cc29ad46891f626272dd5bfd7af2333a4", size = 117462, upload-time = "2026-01-18T20:55:47.726Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/9e/029e898298b2cc662f10d7a15652a53e3b525b1e7f07e21fef8536a09bb8/ormsgpack-1.12.2-cp312-cp312-win_arm64.whl", hash = "sha256:da538c542bac7d1c8f3f2a937863dba36f013108ce63e55745941dda4b75dbb6", size = 111559, upload-time = "2026-01-18T20:55:54.273Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/29/bb0eba3288c0449efbb013e9c6f58aea79cf5cb9ee1921f8865f04c1a9d7/ormsgpack-1.12.2-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:5ea60cb5f210b1cfbad8c002948d73447508e629ec375acb82910e3efa8ff355", size = 378661, upload-time = "2026-01-18T20:55:57.765Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/31/5efa31346affdac489acade2926989e019e8ca98129658a183e3add7af5e/ormsgpack-1.12.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3601f19afdbea273ed70b06495e5794606a8b690a568d6c996a90d7255e51c1", size = 203194, upload-time = "2026-01-18T20:56:08.252Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/56/d0087278beef833187e0167f8527235ebe6f6ffc2a143e9de12a98b1ce87/ormsgpack-1.12.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29a9f17a3dac6054c0dce7925e0f4995c727f7c41859adf9b5572180f640d172", size = 210778, upload-time = "2026-01-18T20:55:17.694Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/a2/072343e1413d9443e5a252a8eb591c2d5b1bffbe5e7bfc78c069361b92eb/ormsgpack-1.12.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39c1bd2092880e413902910388be8715f70b9f15f20779d44e673033a6146f2d", size = 212592, upload-time = "2026-01-18T20:55:32.747Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/8b/a0da3b98a91d41187a63b02dda14267eefc2a74fcb43cc2701066cf1510e/ormsgpack-1.12.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:50b7249244382209877deedeee838aef1542f3d0fc28b8fe71ca9d7e1896a0d7", size = 387164, upload-time = "2026-01-18T20:55:40.853Z" },
-    { url = "https://files.pythonhosted.org/packages/19/bb/6d226bc4cf9fc20d8eb1d976d027a3f7c3491e8f08289a2e76abe96a65f3/ormsgpack-1.12.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:5af04800d844451cf102a59c74a841324868d3f1625c296a06cc655c542a6685", size = 482516, upload-time = "2026-01-18T20:55:42.033Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/f1/bb2c7223398543dedb3dbf8bb93aaa737b387de61c5feaad6f908841b782/ormsgpack-1.12.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cec70477d4371cd524534cd16472d8b9cc187e0e3043a8790545a9a9b296c258", size = 425539, upload-time = "2026-01-18T20:55:24.727Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/e8/0fb45f57a2ada1fed374f7494c8cd55e2f88ccd0ab0a669aa3468716bf5f/ormsgpack-1.12.2-cp313-cp313-win_amd64.whl", hash = "sha256:21f4276caca5c03a818041d637e4019bc84f9d6ca8baa5ea03e5cc8bf56140e9", size = 117459, upload-time = "2026-01-18T20:55:56.876Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/d4/0cfeea1e960d550a131001a7f38a5132c7ae3ebde4c82af1f364ccc5d904/ormsgpack-1.12.2-cp313-cp313-win_arm64.whl", hash = "sha256:baca4b6773d20a82e36d6fd25f341064244f9f86a13dead95dd7d7f996f51709", size = 111577, upload-time = "2026-01-18T20:55:43.605Z" },
-    { url = "https://files.pythonhosted.org/packages/94/16/24d18851334be09c25e87f74307c84950f18c324a4d3c0b41dabdbf19c29/ormsgpack-1.12.2-cp314-cp314-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:bc68dd5915f4acf66ff2010ee47c8906dc1cf07399b16f4089f8c71733f6e36c", size = 378717, upload-time = "2026-01-18T20:55:26.164Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/a2/88b9b56f83adae8032ac6a6fa7f080c65b3baf9b6b64fd3d37bd202991d4/ormsgpack-1.12.2-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46d084427b4132553940070ad95107266656cb646ea9da4975f85cb1a6676553", size = 203183, upload-time = "2026-01-18T20:55:18.815Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/80/43e4555963bf602e5bdc79cbc8debd8b6d5456c00d2504df9775e74b450b/ormsgpack-1.12.2-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c010da16235806cf1d7bc4c96bf286bfa91c686853395a299b3ddb49499a3e13", size = 210814, upload-time = "2026-01-18T20:55:33.973Z" },
-    { url = "https://files.pythonhosted.org/packages/78/e1/7cfbf28de8bca6efe7e525b329c31277d1b64ce08dcba723971c241a9d60/ormsgpack-1.12.2-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18867233df592c997154ff942a6503df274b5ac1765215bceba7a231bea2745d", size = 212634, upload-time = "2026-01-18T20:55:28.634Z" },
-    { url = "https://files.pythonhosted.org/packages/95/f8/30ae5716e88d792a4e879debee195653c26ddd3964c968594ddef0a3cc7e/ormsgpack-1.12.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b009049086ddc6b8f80c76b3955df1aa22a5fbd7673c525cd63bf91f23122ede", size = 387139, upload-time = "2026-01-18T20:56:02.013Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/81/aee5b18a3e3a0e52f718b37ab4b8af6fae0d9d6a65103036a90c2a8ffb5d/ormsgpack-1.12.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1dcc17d92b6390d4f18f937cf0b99054824a7815818012ddca925d6e01c2e49e", size = 482578, upload-time = "2026-01-18T20:55:35.117Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/17/71c9ba472d5d45f7546317f467a5fc941929cd68fb32796ca3d13dcbaec2/ormsgpack-1.12.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f04b5e896d510b07c0ad733d7fce2d44b260c5e6c402d272128f8941984e4285", size = 425539, upload-time = "2026-01-18T20:56:04.009Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/a6/ac99cd7fe77e822fed5250ff4b86fa66dd4238937dd178d2299f10b69816/ormsgpack-1.12.2-cp314-cp314-win_amd64.whl", hash = "sha256:ae3aba7eed4ca7cb79fd3436eddd29140f17ea254b91604aa1eb19bfcedb990f", size = 117493, upload-time = "2026-01-18T20:56:07.343Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/67/339872846a1ae4592535385a1c1f93614138566d7af094200c9c3b45d1e5/ormsgpack-1.12.2-cp314-cp314-win_arm64.whl", hash = "sha256:118576ea6006893aea811b17429bfc561b4778fad393f5f538c84af70b01260c", size = 111579, upload-time = "2026-01-18T20:55:21.161Z" },
-    { url = "https://files.pythonhosted.org/packages/49/c2/6feb972dc87285ad381749d3882d8aecbde9f6ecf908dd717d33d66df095/ormsgpack-1.12.2-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:7121b3d355d3858781dc40dafe25a32ff8a8242b9d80c692fd548a4b1f7fd3c8", size = 378721, upload-time = "2026-01-18T20:55:52.12Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/9a/900a6b9b413e0f8a471cf07830f9cf65939af039a362204b36bd5b581d8b/ormsgpack-1.12.2-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ee766d2e78251b7a63daf1cddfac36a73562d3ddef68cacfb41b2af64698033", size = 203170, upload-time = "2026-01-18T20:55:44.469Z" },
-    { url = "https://files.pythonhosted.org/packages/87/4c/27a95466354606b256f24fad464d7c97ab62bce6cc529dd4673e1179b8fb/ormsgpack-1.12.2-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:292410a7d23de9b40444636b9b8f1e4e4b814af7f1ef476e44887e52a123f09d", size = 212816, upload-time = "2026-01-18T20:55:23.501Z" },
-    { url = "https://files.pythonhosted.org/packages/73/cd/29cee6007bddf7a834e6cd6f536754c0535fcb939d384f0f37a38b1cddb8/ormsgpack-1.12.2-cp314-cp314t-win_amd64.whl", hash = "sha256:837dd316584485b72ef451d08dd3e96c4a11d12e4963aedb40e08f89685d8ec2", size = 117232, upload-time = "2026-01-18T20:55:45.448Z" },
-]
-
 [[package]]
 name = "packaging"
 version = "26.0"
@@ -2285,70 +2012,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", hash = "sha256:f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a", size = 510489, upload-time = "2026-03-03T07:47:49.167Z" },
 ]
 
-[[package]]
-name = "pyyaml"
-version = "6.0.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
-    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
-    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
-    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
-    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
-    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
-    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
-    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
-    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
-    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
-    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
-    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
-    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
-    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
-    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
-    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
-    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
-    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
-    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
-    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
-    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
-    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
-    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
-]
-
 [[package]]
 name = "referencing"
 version = "0.37.0"
@@ -2499,18 +2162,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
 ]
 
-[[package]]
-name = "requests-toolbelt"
-version = "1.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
-]
-
 [[package]]
 name = "rpds-py"
 version = "0.30.0"
@@ -2949,35 +2600,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
 ]
 
-[[package]]
-name = "uuid-utils"
-version = "0.14.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7b/d1/38a573f0c631c062cf42fa1f5d021d4dd3c31fb23e4376e4b56b0c9fbbed/uuid_utils-0.14.1.tar.gz", hash = "sha256:9bfc95f64af80ccf129c604fb6b8ca66c6f256451e32bc4570f760e4309c9b69", size = 22195, upload-time = "2026-02-20T22:50:38.833Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/b7/add4363039a34506a58457d96d4aa2126061df3a143eb4d042aedd6a2e76/uuid_utils-0.14.1-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:93a3b5dc798a54a1feb693f2d1cb4cf08258c32ff05ae4929b5f0a2ca624a4f0", size = 604679, upload-time = "2026-02-20T22:50:27.469Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/84/d1d0bef50d9e66d31b2019997c741b42274d53dde2e001b7a83e9511c339/uuid_utils-0.14.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:ccd65a4b8e83af23eae5e56d88034b2fe7264f465d3e830845f10d1591b81741", size = 309346, upload-time = "2026-02-20T22:50:31.857Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/ed/b6d6fd52a6636d7c3eddf97d68da50910bf17cd5ac221992506fb56cf12e/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b56b0cacd81583834820588378e432b0696186683b813058b707aedc1e16c4b1", size = 344714, upload-time = "2026-02-20T22:50:42.642Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/a7/a19a1719fb626fe0b31882db36056d44fe904dc0cf15b06fdf56b2679cf7/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb3cf14de789097320a3c56bfdfdd51b1225d11d67298afbedee7e84e3837c96", size = 350914, upload-time = "2026-02-20T22:50:36.487Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/fc/f6690e667fdc3bb1a73f57951f97497771c56fe23e3d302d7404be394d4f/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:60e0854a90d67f4b0cc6e54773deb8be618f4c9bad98d3326f081423b5d14fae", size = 482609, upload-time = "2026-02-20T22:50:37.511Z" },
-    { url = "https://files.pythonhosted.org/packages/54/6e/dcd3fa031320921a12ec7b4672dea3bd1dd90ddffa363a91831ba834d559/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce6743ba194de3910b5feb1a62590cd2587e33a73ab6af8a01b642ceb5055862", size = 345699, upload-time = "2026-02-20T22:50:46.87Z" },
-    { url = "https://files.pythonhosted.org/packages/04/28/e5220204b58b44ac0047226a9d016a113fde039280cc8732d9e6da43b39f/uuid_utils-0.14.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:043fb58fde6cf1620a6c066382f04f87a8e74feb0f95a585e4ed46f5d44af57b", size = 372205, upload-time = "2026-02-20T22:50:28.438Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/d9/3d2eb98af94b8dfffc82b6a33b4dfc87b0a5de2c68a28f6dde0db1f8681b/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c915d53f22945e55fe0d3d3b0b87fd965a57f5fd15666fd92d6593a73b1dd297", size = 521836, upload-time = "2026-02-20T22:50:23.057Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/15/0eb106cc6fe182f7577bc0ab6e2f0a40be247f35c5e297dbf7bbc460bd02/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:0972488e3f9b449e83f006ead5a0e0a33ad4a13e4462e865b7c286ab7d7566a3", size = 625260, upload-time = "2026-02-20T22:50:25.949Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/17/f539507091334b109e7496830af2f093d9fc8082411eafd3ece58af1f8ba/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:1c238812ae0c8ffe77d8d447a32c6dfd058ea4631246b08b5a71df586ff08531", size = 587824, upload-time = "2026-02-20T22:50:35.225Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/c2/d37a7b2e41f153519367d4db01f0526e0d4b06f1a4a87f1c5dfca5d70a8b/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:bec8f8ef627af86abf8298e7ec50926627e29b34fa907fcfbedb45aaa72bca43", size = 551407, upload-time = "2026-02-20T22:50:44.915Z" },
-    { url = "https://files.pythonhosted.org/packages/65/36/2d24b2cbe78547c6532da33fb8613debd3126eccc33a6374ab788f5e46e9/uuid_utils-0.14.1-cp39-abi3-win32.whl", hash = "sha256:b54d6aa6252d96bac1fdbc80d26ba71bad9f220b2724d692ad2f2310c22ef523", size = 183476, upload-time = "2026-02-20T22:50:32.745Z" },
-    { url = "https://files.pythonhosted.org/packages/83/92/2d7e90df8b1a69ec4cff33243ce02b7a62f926ef9e2f0eca5a026889cd73/uuid_utils-0.14.1-cp39-abi3-win_amd64.whl", hash = "sha256:fc27638c2ce267a0ce3e06828aff786f91367f093c80625ee21dad0208e0f5ba", size = 187147, upload-time = "2026-02-20T22:50:45.807Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/26/529f4beee17e5248e37e0bc17a2761d34c0fa3b1e5729c88adb2065bae6e/uuid_utils-0.14.1-cp39-abi3-win_arm64.whl", hash = "sha256:b04cb49b42afbc4ff8dbc60cf054930afc479d6f4dd7f1ec3bbe5dbfdde06b7a", size = 188132, upload-time = "2026-02-20T22:50:41.718Z" },
-    { url = "https://files.pythonhosted.org/packages/91/f9/6c64bdbf71f58ccde7919e00491812556f446a5291573af92c49a5e9aaef/uuid_utils-0.14.1-pp311-pypy311_pp73-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:b197cd5424cf89fb019ca7f53641d05bfe34b1879614bed111c9c313b5574cd8", size = 591617, upload-time = "2026-02-20T22:50:24.532Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/f0/758c3b0fb0c4871c7704fef26a5bc861de4f8a68e4831669883bebe07b0f/uuid_utils-0.14.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:12c65020ba6cb6abe1d57fcbfc2d0ea0506c67049ee031714057f5caf0f9bc9c", size = 303702, upload-time = "2026-02-20T22:50:40.687Z" },
-    { url = "https://files.pythonhosted.org/packages/85/89/d91862b544c695cd58855efe3201f83894ed82fffe34500774238ab8eba7/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b5d2ad28063d422ccc2c28d46471d47b61a58de885d35113a8f18cb547e25bf", size = 337678, upload-time = "2026-02-20T22:50:39.768Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/6b/cf342ba8a898f1de024be0243fac67c025cad530c79ea7f89c4ce718891a/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:da2234387b45fde40b0fedfee64a0ba591caeea9c48c7698ab6e2d85c7991533", size = 343711, upload-time = "2026-02-20T22:50:43.965Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/20/049418d094d396dfa6606b30af925cc68a6670c3b9103b23e6990f84b589/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50fffc2827348c1e48972eed3d1c698959e63f9d030aa5dd82ba451113158a62", size = 476731, upload-time = "2026-02-20T22:50:30.589Z" },
-    { url = "https://files.pythonhosted.org/packages/77/a1/0857f64d53a90321e6a46a3d4cc394f50e1366132dcd2ae147f9326ca98b/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1dbe718765f70f5b7f9b7f66b6a937802941b1cc56bcf642ce0274169741e01", size = 338902, upload-time = "2026-02-20T22:50:33.927Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/d0/5bf7cbf1ac138c92b9ac21066d18faf4d7e7f651047b700eb192ca4b9fdb/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:258186964039a8e36db10810c1ece879d229b01331e09e9030bc5dcabe231bd2", size = 364700, upload-time = "2026-02-20T22:50:21.732Z" },
-]
-
 [[package]]
 name = "uvicorn"
 version = "0.44.0"
@@ -3105,124 +2727,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1a/c7/8528ac2dfa2c1e6708f647df7ae144ead13f0a31146f43c7264b4942bf12/wrapt-2.1.2-py3-none-any.whl", hash = "sha256:b8fd6fa2b2c4e7621808f8c62e8317f4aae56e59721ad933bac5239d913cf0e8", size = 43993, upload-time = "2026-03-06T02:53:12.905Z" },
 ]
 
-[[package]]
-name = "xxhash"
-version = "3.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/b1/93508d9460b292c74a09b83d16750c52a0ead89c51eea9951cb97a60d959/xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d", size = 30807, upload-time = "2025-10-02T14:33:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/07/55/28c93a3662f2d200c70704efe74aab9640e824f8ce330d8d3943bf7c9b3c/xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8", size = 193786, upload-time = "2025-10-02T14:33:54.272Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/96/fec0be9bb4b8f5d9c57d76380a366f31a1781fb802f76fc7cda6c84893c7/xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058", size = 212830, upload-time = "2025-10-02T14:33:55.706Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/a0/c706845ba77b9611f81fd2e93fad9859346b026e8445e76f8c6fd057cc6d/xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2", size = 211606, upload-time = "2025-10-02T14:33:57.133Z" },
-    { url = "https://files.pythonhosted.org/packages/67/1e/164126a2999e5045f04a69257eea946c0dc3e86541b400d4385d646b53d7/xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc", size = 444872, upload-time = "2025-10-02T14:33:58.446Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/4b/55ab404c56cd70a2cf5ecfe484838865d0fea5627365c6c8ca156bd09c8f/xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc", size = 193217, upload-time = "2025-10-02T14:33:59.724Z" },
-    { url = "https://files.pythonhosted.org/packages/45/e6/52abf06bac316db33aa269091ae7311bd53cfc6f4b120ae77bac1b348091/xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07", size = 210139, upload-time = "2025-10-02T14:34:02.041Z" },
-    { url = "https://files.pythonhosted.org/packages/34/37/db94d490b8691236d356bc249c08819cbcef9273a1a30acf1254ff9ce157/xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4", size = 197669, upload-time = "2025-10-02T14:34:03.664Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/36/c4f219ef4a17a4f7a64ed3569bc2b5a9c8311abdb22249ac96093625b1a4/xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06", size = 210018, upload-time = "2025-10-02T14:34:05.325Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/06/bfac889a374fc2fc439a69223d1750eed2e18a7db8514737ab630534fa08/xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4", size = 413058, upload-time = "2025-10-02T14:34:06.925Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/d1/555d8447e0dd32ad0930a249a522bb2e289f0d08b6b16204cfa42c1f5a0c/xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b", size = 190628, upload-time = "2025-10-02T14:34:08.669Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/15/8751330b5186cedc4ed4b597989882ea05e0408b53fa47bcb46a6125bfc6/xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b", size = 30577, upload-time = "2025-10-02T14:34:10.234Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/cc/53f87e8b5871a6eb2ff7e89c48c66093bda2be52315a8161ddc54ea550c4/xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb", size = 31487, upload-time = "2025-10-02T14:34:11.618Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/00/60f9ea3bb697667a14314d7269956f58bf56bb73864f8f8d52a3c2535e9a/xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d", size = 27863, upload-time = "2025-10-02T14:34:12.619Z" },
-    { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" },
-    { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" },
-    { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" },
-    { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" },
-    { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" },
-    { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" },
-    { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" },
-    { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" },
-    { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" },
-    { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" },
-    { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" },
-    { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" },
-    { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" },
-    { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" },
-    { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" },
-    { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" },
-    { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" },
-    { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" },
-    { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" },
-    { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" },
-    { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" },
-    { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" },
-    { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" },
-    { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" },
-    { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" },
-    { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" },
-    { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" },
-    { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" },
-    { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/ee/3cf8589e06c2164ac77c3bf0aa127012801128f1feebf2a079272da5737c/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f", size = 31214, upload-time = "2025-10-02T14:35:54.746Z" },
-    { url = "https://files.pythonhosted.org/packages/02/5d/a19552fbc6ad4cb54ff953c3908bbc095f4a921bc569433d791f755186f1/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad", size = 32290, upload-time = "2025-10-02T14:35:55.791Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/11/dafa0643bc30442c887b55baf8e73353a344ee89c1901b5a5c54a6c17d39/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679", size = 28795, upload-time = "2025-10-02T14:35:57.162Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" },
-    { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" },
-    { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" },
-    { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" },
-    { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" },
-    { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/9a/c19c42c5b3f5a4aad748a6d5b4f23df3bed7ee5445accc65a0fb3ff03953/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119", size = 31586, upload-time = "2025-10-02T14:36:15.603Z" },
-    { url = "https://files.pythonhosted.org/packages/03/d6/4cc450345be9924fd5dc8c590ceda1db5b43a0a889587b0ae81a95511360/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f", size = 32526, upload-time = "2025-10-02T14:36:16.708Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/c9/7243eb3f9eaabd1a88a5a5acadf06df2d83b100c62684b7425c6a11bcaa8/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95", size = 28898, upload-time = "2025-10-02T14:36:17.843Z" },
-    { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" },
-    { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" },
-    { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
-]
-
 [[package]]
 name = "zipp"
 version = "3.23.1"
@@ -3231,93 +2735,3 @@ sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964d
 wheels = [
     { url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", hash = "sha256:0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc", size = 10378, upload-time = "2026-04-13T23:21:45.386Z" },
 ]
-
-[[package]]
-name = "zstandard"
-version = "0.25.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload-time = "2025-09-14T22:15:56.415Z" },
-    { url = "https://files.pythonhosted.org/packages/96/34/ef34ef77f1ee38fc8e4f9775217a613b452916e633c4f1d98f31db52c4a5/zstandard-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7", size = 640565, upload-time = "2025-09-14T22:15:58.177Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/1b/4fdb2c12eb58f31f28c4d28e8dc36611dd7205df8452e63f52fb6261d13e/zstandard-0.25.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550", size = 5345306, upload-time = "2025-09-14T22:16:00.165Z" },
-    { url = "https://files.pythonhosted.org/packages/73/28/a44bdece01bca027b079f0e00be3b6bd89a4df180071da59a3dd7381665b/zstandard-0.25.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d", size = 5055561, upload-time = "2025-09-14T22:16:02.22Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/74/68341185a4f32b274e0fc3410d5ad0750497e1acc20bd0f5b5f64ce17785/zstandard-0.25.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b", size = 5402214, upload-time = "2025-09-14T22:16:04.109Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/67/f92e64e748fd6aaffe01e2b75a083c0c4fd27abe1c8747fee4555fcee7dd/zstandard-0.25.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0", size = 5449703, upload-time = "2025-09-14T22:16:06.312Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/e5/6d36f92a197c3c17729a2125e29c169f460538a7d939a27eaaa6dcfcba8e/zstandard-0.25.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0", size = 5556583, upload-time = "2025-09-14T22:16:08.457Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/83/41939e60d8d7ebfe2b747be022d0806953799140a702b90ffe214d557638/zstandard-0.25.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd", size = 5045332, upload-time = "2025-09-14T22:16:10.444Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/87/d3ee185e3d1aa0133399893697ae91f221fda79deb61adbe998a7235c43f/zstandard-0.25.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701", size = 5572283, upload-time = "2025-09-14T22:16:12.128Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/1d/58635ae6104df96671076ac7d4ae7816838ce7debd94aecf83e30b7121b0/zstandard-0.25.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1", size = 4959754, upload-time = "2025-09-14T22:16:14.225Z" },
-    { url = "https://files.pythonhosted.org/packages/75/d6/57e9cb0a9983e9a229dd8fd2e6e96593ef2aa82a3907188436f22b111ccd/zstandard-0.25.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150", size = 5266477, upload-time = "2025-09-14T22:16:16.343Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a9/ee891e5edf33a6ebce0a028726f0bbd8567effe20fe3d5808c42323e8542/zstandard-0.25.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab", size = 5440914, upload-time = "2025-09-14T22:16:18.453Z" },
-    { url = "https://files.pythonhosted.org/packages/58/08/a8522c28c08031a9521f27abc6f78dbdee7312a7463dd2cfc658b813323b/zstandard-0.25.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e", size = 5819847, upload-time = "2025-09-14T22:16:20.559Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/11/4c91411805c3f7b6f31c60e78ce347ca48f6f16d552fc659af6ec3b73202/zstandard-0.25.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74", size = 5363131, upload-time = "2025-09-14T22:16:22.206Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/d6/8c4bd38a3b24c4c7676a7a3d8de85d6ee7a983602a734b9f9cdefb04a5d6/zstandard-0.25.0-cp310-cp310-win32.whl", hash = "sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa", size = 436469, upload-time = "2025-09-14T22:16:25.002Z" },
-    { url = "https://files.pythonhosted.org/packages/93/90/96d50ad417a8ace5f841b3228e93d1bb13e6ad356737f42e2dde30d8bd68/zstandard-0.25.0-cp310-cp310-win_amd64.whl", hash = "sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e", size = 506100, upload-time = "2025-09-14T22:16:23.569Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload-time = "2025-09-14T22:16:26.137Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload-time = "2025-09-14T22:16:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload-time = "2025-09-14T22:16:29.523Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload-time = "2025-09-14T22:16:31.811Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload-time = "2025-09-14T22:16:33.486Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload-time = "2025-09-14T22:16:35.277Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload-time = "2025-09-14T22:16:37.141Z" },
-    { url = "https://files.pythonhosted.org/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload-time = "2025-09-14T22:16:38.807Z" },
-    { url = "https://files.pythonhosted.org/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload-time = "2025-09-14T22:16:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload-time = "2025-09-14T22:16:43.3Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload-time = "2025-09-14T22:16:45.292Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload-time = "2025-09-14T22:16:47.076Z" },
-    { url = "https://files.pythonhosted.org/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload-time = "2025-09-14T22:16:49.316Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload-time = "2025-09-14T22:16:51.328Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload-time = "2025-09-14T22:16:55.005Z" },
-    { url = "https://files.pythonhosted.org/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload-time = "2025-09-14T22:16:52.753Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload-time = "2025-09-14T22:16:53.878Z" },
-    { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" },
-    { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload-time = "2025-09-14T22:17:01.156Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload-time = "2025-09-14T22:17:03.091Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload-time = "2025-09-14T22:17:04.979Z" },
-    { url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload-time = "2025-09-14T22:17:06.781Z" },
-    { url = "https://files.pythonhosted.org/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload-time = "2025-09-14T22:17:08.415Z" },
-    { url = "https://files.pythonhosted.org/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload-time = "2025-09-14T22:17:10.164Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload-time = "2025-09-14T22:17:11.857Z" },
-    { url = "https://files.pythonhosted.org/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload-time = "2025-09-14T22:17:13.627Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload-time = "2025-09-14T22:17:16.103Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload-time = "2025-09-14T22:17:17.827Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload-time = "2025-09-14T22:17:19.954Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload-time = "2025-09-14T22:17:24.398Z" },
-    { url = "https://files.pythonhosted.org/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload-time = "2025-09-14T22:17:21.429Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload-time = "2025-09-14T22:17:23.147Z" },
-    { url = "https://files.pythonhosted.org/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload-time = "2025-09-14T22:17:26.042Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload-time = "2025-09-14T22:17:27.366Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload-time = "2025-09-14T22:17:28.896Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload-time = "2025-09-14T22:17:31.044Z" },
-    { url = "https://files.pythonhosted.org/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload-time = "2025-09-14T22:17:32.711Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload-time = "2025-09-14T22:17:34.41Z" },
-    { url = "https://files.pythonhosted.org/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload-time = "2025-09-14T22:17:36.084Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload-time = "2025-09-14T22:17:37.891Z" },
-    { url = "https://files.pythonhosted.org/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload-time = "2025-09-14T22:17:40.206Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload-time = "2025-09-14T22:17:41.879Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload-time = "2025-09-14T22:17:43.577Z" },
-    { url = "https://files.pythonhosted.org/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload-time = "2025-09-14T22:17:45.271Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload-time = "2025-09-14T22:17:47.08Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload-time = "2025-09-14T22:17:48.893Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload-time = "2025-09-14T22:17:52.658Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload-time = "2025-09-14T22:17:50.402Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload-time = "2025-09-14T22:17:51.533Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/5c/f8923b595b55fe49e30612987ad8bf053aef555c14f05bb659dd5dbe3e8a/zstandard-0.25.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e29f0cf06974c899b2c188ef7f783607dbef36da4c242eb6c82dcd8b512855e3", size = 795887, upload-time = "2025-09-14T22:17:54.198Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/09/d0a2a14fc3439c5f874042dca72a79c70a532090b7ba0003be73fee37ae2/zstandard-0.25.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:05df5136bc5a011f33cd25bc9f506e7426c0c9b3f9954f056831ce68f3b6689f", size = 640658, upload-time = "2025-09-14T22:17:55.423Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/7c/8b6b71b1ddd517f68ffb55e10834388d4f793c49c6b83effaaa05785b0b4/zstandard-0.25.0-cp314-cp314-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:f604efd28f239cc21b3adb53eb061e2a205dc164be408e553b41ba2ffe0ca15c", size = 5379849, upload-time = "2025-09-14T22:17:57.372Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/86/a48e56320d0a17189ab7a42645387334fba2200e904ee47fc5a26c1fd8ca/zstandard-0.25.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223415140608d0f0da010499eaa8ccdb9af210a543fac54bce15babbcfc78439", size = 5058095, upload-time = "2025-09-14T22:17:59.498Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/ad/eb659984ee2c0a779f9d06dbfe45e2dc39d99ff40a319895df2d3d9a48e5/zstandard-0.25.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e54296a283f3ab5a26fc9b8b5d4978ea0532f37b231644f367aa588930aa043", size = 5551751, upload-time = "2025-09-14T22:18:01.618Z" },
-    { url = "https://files.pythonhosted.org/packages/61/b3/b637faea43677eb7bd42ab204dfb7053bd5c4582bfe6b1baefa80ac0c47b/zstandard-0.25.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ca54090275939dc8ec5dea2d2afb400e0f83444b2fc24e07df7fdef677110859", size = 6364818, upload-time = "2025-09-14T22:18:03.769Z" },
-    { url = "https://files.pythonhosted.org/packages/31/dc/cc50210e11e465c975462439a492516a73300ab8caa8f5e0902544fd748b/zstandard-0.25.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e09bb6252b6476d8d56100e8147b803befa9a12cea144bbe629dd508800d1ad0", size = 5560402, upload-time = "2025-09-14T22:18:05.954Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/ae/56523ae9c142f0c08efd5e868a6da613ae76614eca1305259c3bf6a0ed43/zstandard-0.25.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a9ec8c642d1ec73287ae3e726792dd86c96f5681eb8df274a757bf62b750eae7", size = 4955108, upload-time = "2025-09-14T22:18:07.68Z" },
-    { url = "https://files.pythonhosted.org/packages/98/cf/c899f2d6df0840d5e384cf4c4121458c72802e8bda19691f3b16619f51e9/zstandard-0.25.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4089a10e598eae6393756b036e0f419e8c1d60f44a831520f9af41c14216cf2", size = 5269248, upload-time = "2025-09-14T22:18:09.753Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/c0/59e912a531d91e1c192d3085fc0f6fb2852753c301a812d856d857ea03c6/zstandard-0.25.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f67e8f1a324a900e75b5e28ffb152bcac9fbed1cc7b43f99cd90f395c4375344", size = 5430330, upload-time = "2025-09-14T22:18:11.966Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/1d/7e31db1240de2df22a58e2ea9a93fc6e38cc29353e660c0272b6735d6669/zstandard-0.25.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9654dbc012d8b06fc3d19cc825af3f7bf8ae242226df5f83936cb39f5fdc846c", size = 5811123, upload-time = "2025-09-14T22:18:13.907Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/49/fac46df5ad353d50535e118d6983069df68ca5908d4d65b8c466150a4ff1/zstandard-0.25.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4203ce3b31aec23012d3a4cf4a2ed64d12fea5269c49aed5e4c3611b938e4088", size = 5359591, upload-time = "2025-09-14T22:18:16.465Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/38/f249a2050ad1eea0bb364046153942e34abba95dd5520af199aed86fbb49/zstandard-0.25.0-cp314-cp314-win32.whl", hash = "sha256:da469dc041701583e34de852d8634703550348d5822e66a0c827d39b05365b12", size = 444513, upload-time = "2025-09-14T22:18:20.61Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/43/241f9615bcf8ba8903b3f0432da069e857fc4fd1783bd26183db53c4804b/zstandard-0.25.0-cp314-cp314-win_amd64.whl", hash = "sha256:c19bcdd826e95671065f8692b5a4aa95c52dc7a02a4c5a0cac46deb879a017a2", size = 516118, upload-time = "2025-09-14T22:18:17.849Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/ef/da163ce2450ed4febf6467d77ccb4cd52c4c30ab45624bad26ca0a27260c/zstandard-0.25.0-cp314-cp314-win_arm64.whl", hash = "sha256:d7541afd73985c630bafcd6338d2518ae96060075f9463d7dc14cfb33514383d", size = 476940, upload-time = "2025-09-14T22:18:19.088Z" },
-]