refactor: remove dead code and simplify across backend, SDK, and frontend

Backend: delete collector/scorer.py and collector/intelligence.py
re-export wrappers, update 15 import sites to canonical paths,
fix pre-existing broken import in collector/server.py.

SDK: simplify event registry from custom lazy-loading class to plain
dict (lazy-loading was never used — registry eagerly populated),
remove duplicated event_value fallback in scorer, delete test for
removed lazy-loading mechanism.

Frontend: remove 4 unused components (PolicyDiffView,
FailureExplanationModal, LiveSummaryPanel, FailureExplanationCard,
357 lines), simplify LiveDashboard (remove dead props/metrics section),
clean unused types from types/index.ts (repair fields, ReplayState,
RollingSummary, EscalationSignal, PolicyShift).

Net: -534 lines across 28 files.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: acailic

agent_debugger_sdk/core/events/registry.py

@@ -2,66 +2,8 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from .base import EventType, TraceEvent
 
-if TYPE_CHECKING:
-    # Type hints for type checkers - these imports are used at runtime in _get_event_classes()
-    from .agent import AgentTurnEvent, BehaviorAlertEvent  # noqa: F401
-    from .decisions import DecisionEvent  # noqa: F401
-    from .errors import ErrorEvent  # noqa: F401
-    from .llm import LLMRequestEvent, LLMResponseEvent  # noqa: F401
-    from .safety import (  # noqa: F401
-        PolicyViolationEvent,
-        PromptPolicyEvent,
-        RefusalEvent,
-        SafetyCheckEvent,
-    )
-    from .tools import ToolCallEvent, ToolResultEvent  # noqa: F401
-
-
-# Deferred imports to avoid circular dependencies
-def _get_event_classes() -> dict[EventType, type[TraceEvent]]:
-    """Lazily import event classes to avoid circular dependencies."""
-    from .agent import AgentTurnEvent, BehaviorAlertEvent
-    from .decisions import DecisionEvent
-    from .errors import ErrorEvent
-    from .llm import LLMRequestEvent, LLMResponseEvent
-    from .safety import (
-        PolicyViolationEvent,
-        PromptPolicyEvent,
-        RefusalEvent,
-        SafetyCheckEvent,
-    )
-    from .tools import ToolCallEvent, ToolResultEvent
-
-    return {
-        EventType.TOOL_CALL: ToolCallEvent,
-        EventType.TOOL_RESULT: ToolResultEvent,
-        EventType.LLM_REQUEST: LLMRequestEvent,
-        EventType.LLM_RESPONSE: LLMResponseEvent,
-        EventType.DECISION: DecisionEvent,
-        EventType.SAFETY_CHECK: SafetyCheckEvent,
-        EventType.REFUSAL: RefusalEvent,
-        EventType.POLICY_VIOLATION: PolicyViolationEvent,
-        EventType.PROMPT_POLICY: PromptPolicyEvent,
-        EventType.AGENT_TURN: AgentTurnEvent,
-        EventType.BEHAVIOR_ALERT: BehaviorAlertEvent,
-        EventType.ERROR: ErrorEvent,
-    }
-
-
-# Create the registry as a lazily-evaluated mapping
-class _EventTypeRegistry(dict[EventType, type[TraceEvent]]):
-    """Lazy-loading registry for event type mappings."""
-
-    def __missing__(self, key: EventType) -> type[TraceEvent]:
-        """Load event classes on first access."""
-        self.update(_get_event_classes())
-        if key in self:
-            return self[key]
-        raise KeyError(f"EventType {key} not found in registry")
-
-
-EVENT_TYPE_REGISTRY: dict[EventType, type[TraceEvent]] = _EventTypeRegistry()
+# Simple registry for event type mappings.
+# The registry is populated by __init__.py to ensure class identity consistency.
+EVENT_TYPE_REGISTRY: dict[EventType, type[TraceEvent]] = {}

agent_debugger_sdk/core/scorer.py

@@ -10,19 +10,9 @@
 
 from agent_debugger_sdk.core.events import EventType, TraceEvent
 
-# Import event_value from collector helpers to consolidate duplication
-# Note: This is safe because helpers.py only imports TraceEvent, not scorer
-try:
-    from collector.intelligence.helpers import event_value
-except ImportError:
-    # Fallback for environments where collector is not available
-    def event_value(event: TraceEvent | None, key: str, default: object = None) -> object:
-        """Read structured event fields before falling back to event.data."""
-        if event is None:
-            return default
-        if hasattr(event, key):
-            return getattr(event, key)
-        return event.data.get(key, default)
+# Import event_value from collector helpers.
+# This is safe because helpers.py only imports TraceEvent, not scorer.
+from collector.intelligence.helpers import event_value
 
 
 @dataclass

api/app_context.py

@@ -4,7 +4,7 @@
 
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
 
-from collector.intelligence import TraceIntelligence
+from collector.intelligence.facade import TraceIntelligence
 from redaction.pipeline import RedactionPipeline
 from storage.engine import create_db_engine, create_session_maker
 

api/services.py

@@ -14,7 +14,7 @@
 from api import app_context
 from api.schemas import CheckpointSchema, SessionSchema, TraceEventSchema
 from collector.buffer import EventBuffer, get_event_buffer
-from collector.intelligence import TraceIntelligence
+from collector.intelligence.facade import TraceIntelligence
 from redaction.pipeline import RedactionPipeline
 from storage import TraceRepository
 

collector/__init__.py

@@ -8,17 +8,14 @@
 from . import persistence  # noqa: F401
 from .buffer import EventBuffer, get_event_buffer
 from .buffer_base import BufferBase
-from .intelligence import TraceIntelligence
+from .intelligence.facade import TraceIntelligence
 from .persistence import PersistenceManager
-from .scorer import ImportanceScorer, get_importance_scorer
 
 __all__ = [
     "EventBuffer",
     "get_event_buffer",
     "BufferBase",
     "create_buffer",
-    "ImportanceScorer",
-    "get_importance_scorer",
     "TraceIntelligence",
     "PersistenceManager",
 ]

collector/intelligence.py

@@ -21,12 +21,12 @@
     Session,
     TraceEvent,
 )
+from agent_debugger_sdk.core.scorer import get_importance_scorer
 from auth.middleware import get_tenant_from_api_key
 from redaction.pipeline import RedactionPipeline
 from storage import TraceRepository
 
 from .buffer import get_event_buffer
-from .scorer import get_importance_scorer
 
 # Input size limits for security (DoS prevention)
 MAX_DATA_SIZE_BYTES = 1 * 1024 * 1024  # 1MB