agent-learning-kit 0.1.0__py3-none-any.whl

fi/opt/components.py

@@ -0,0 +1,3095 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Iterable, List, Literal, Optional, Sequence, Set
+
+from pydantic import BaseModel, Field, field_validator
+
+
+AgentComponent = Literal[
+    "objective",
+    "harness",
+    "integration",
+    "framework",
+    "orchestration",
+    "streaming",
+    "world",
+    "security",
+    "perception",
+    "prompt",
+    "planner",
+    "autonomy",
+    "router",
+    "tools",
+    "memory",
+    "retrieval",
+    "policy",
+    "action",
+    "environment",
+    "implementation",
+    "evaluator",
+    "multi_agent",
+    "model",
+    "voice",
+    "browser",
+    "cua",
+    "custom",
+]
+
+
+FailureMode = Literal[
+    "unclear_goal",
+    "poor_plan",
+    "wrong_tool",
+    "bad_tool_arguments",
+    "tool_execution_error",
+    "missing_tool",
+    "memory_write_failure",
+    "memory_retrieval_failure",
+    "memory_contamination",
+    "retrieval_relevance_failure",
+    "policy_violation",
+    "unsafe_action",
+    "hallucination",
+    "schema_error",
+    "environment_mismatch",
+    "latency_or_cost",
+    "coordination_failure",
+    "evaluation_gap",
+    "integration_gap",
+    "implementation_bug",
+    "perception_grounding_failure",
+    "artifact_semantics_failure",
+    "domain_package_failure",
+    "context_overload",
+    "voice_turn_taking_failure",
+    "voice_timing_distribution_failure",
+    "browser_action_failure",
+    "browser_mutation_failure",
+    "autonomy_loop_failure",
+    "cross_trial_memory_skill_failure",
+    "framework_trace_gap",
+    "framework_lifecycle_gap",
+    "framework_capability_gap",
+    "framework_probe_gap",
+    "framework_portability_gap",
+    "trust_boundary_gap",
+    "control_plane_gap",
+    "framework_transcript_gap",
+    "orchestration_trace_gap",
+    "orchestration_flow_failure",
+    "streaming_trace_gap",
+    "streaming_interaction_failure",
+    "world_contract_gap",
+    "world_contract_violation",
+    "adversarial_resilience_failure",
+    "reliability_failure",
+    "fault_tolerance_failure",
+    "unknown",
+]
+
+
+class AgentComponentSpec(BaseModel):
+    """A component that can be measured and optimized."""
+
+    name: AgentComponent
+    config_paths: List[str] = Field(default_factory=list)
+    metrics: List[str] = Field(default_factory=list)
+    failure_modes: List[FailureMode] = Field(default_factory=list)
+    patch_strategies: List[str] = Field(default_factory=list)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+HARNESS_LAYERS = (
+    "execution",
+    "tool_interface",
+    "context_memory",
+    "lifecycle",
+    "observability",
+    "verification",
+    "governance",
+)
+
+# Layer -> admissible search-path prefixes. Built from the SAME path families
+# COMPONENT_SPECS already uses (e.g. the "harness" spec's framework.runtime.*,
+# framework.lifecycle.*, framework.capabilities.* path groups) so layer scoping
+# and component scoping cannot disagree: every prefix below appears in some
+# spec's config_paths (asserted by the Phase-4 locality tests).
+HARNESS_LAYER_PATH_PREFIXES: Dict[str, tuple[str, ...]] = {
+    "execution": ("simulation", "harness", "framework.runtime", "framework.runtime.method"),
+    "tool_interface": ("tools", "framework.capabilities.tools", "framework.lifecycle.tool_registration"),
+    "context_memory": ("memory", "retrieval", "retriever", "framework.capabilities.memory"),
+    "lifecycle": ("framework.lifecycle", "framework.lifecycle.sessions", "framework.lifecycle.checkpoints"),
+    "observability": ("framework.trace", "framework.trace.export", "framework.import.event_streams"),
+    "verification": ("evaluation", "evaluation.trajectory_templates", "rubric"),
+    "governance": ("security", "policy", "framework.trust_boundary", "environment"),
+}
+
+
+class ComponentDiagnosis(BaseModel):
+    """Evidence-backed route from observed failure to component-level patch space."""
+
+    component: AgentComponent
+    failure_mode: FailureMode
+    confidence: float = Field(1.0, ge=0.0, le=1.0)
+    evidence: str = ""
+    suggested_paths: List[str] = Field(default_factory=list)
+    suggested_metrics: List[str] = Field(default_factory=list)
+    patch_strategy: Optional[str] = None
+    harness_layer: Optional[str] = None  # member of HARNESS_LAYERS or None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator("harness_layer")
+    @classmethod
+    def _validate_harness_layer(cls, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return value
+        if value not in HARNESS_LAYERS:
+            raise ValueError(
+                f"harness_layer must be one of {HARNESS_LAYERS} or None, got {value!r}."
+            )
+        return value
+
+
+COMPONENT_SPECS: Dict[AgentComponent, AgentComponentSpec] = {
+    "objective": AgentComponentSpec(
+        name="objective",
+        config_paths=["objective", "task", "rubric", "trajectory_templates", "evaluation.trajectory_templates"],
+        metrics=["task_completion", "goal_accuracy", "agent_goal_accuracy"],
+        failure_modes=["unclear_goal", "evaluation_gap"],
+        patch_strategies=["clarify success criteria", "add reference state checks"],
+    ),
+    "harness": AgentComponentSpec(
+        name="harness",
+        config_paths=[
+            "simulation",
+            "harness",
+            "environment.fixtures",
+            "evaluation.trajectory_templates",
+            "framework.trace",
+            "framework.import_manifest",
+            "framework.import.sources",
+            "framework.import.trace_exports",
+            "framework.import.event_streams",
+            "framework.import.lifecycle",
+            "framework.import.capabilities",
+            "framework.import.probes",
+            "framework.import.portability",
+            "framework.trace.export",
+            "framework.trace.export.auth",
+            "framework.trace.export.pagination",
+            "framework.runtime",
+            "framework.runtime.method",
+            "framework.runtime.input_mode",
+            "framework.runtime.output_schema",
+            "framework.runtime.trace_runtime",
+            "framework.runtime.contract",
+            "framework.lifecycle",
+            "framework.lifecycle.phases",
+            "framework.lifecycle.sessions",
+            "framework.lifecycle.tool_registration",
+            "framework.lifecycle.checkpoints",
+            "framework.lifecycle.retry_policy",
+            "framework.lifecycle.cancel_resume",
+            "framework.lifecycle.cleanup",
+            "framework.capabilities",
+            "framework.capabilities.tools",
+            "framework.capabilities.memory",
+            "framework.capabilities.streaming",
+            "framework.capabilities.lifecycle",
+            "framework.capabilities.orchestration",
+            "framework.capabilities.security",
+            "framework.capabilities.observability",
+            "framework.capabilities.exports",
+            "framework.probes",
+            "framework.probes.invoke",
+            "framework.probes.tools",
+            "framework.probes.memory",
+            "framework.probes.streaming",
+            "framework.probes.lifecycle",
+            "framework.probes.orchestration",
+            "framework.probes.security",
+            "framework.probes.observability",
+            "framework.probes.exports",
+            "framework.portability",
+            "framework.portability.source",
+            "framework.portability.target",
+            "framework.portability.mappings",
+            "framework.portability.tools",
+            "framework.portability.memory",
+            "framework.portability.streaming",
+            "framework.portability.lifecycle",
+            "framework.portability.orchestration",
+            "framework.portability.security",
+            "framework.portability.observability",
+            "framework.portability.exports",
+            "framework.portability.browser",
+            "framework.portability.voice",
+            "framework.portability.runtime",
+            "framework.memory",
+            "framework.checkpoints",
+            "framework.checkpoints.state",
+            "framework.checkpoints.parent",
+            "framework.sessions",
+            "framework.sessions.thread_id",
+            "framework.events",
+            "framework.transcript",
+            "mcp.tool_session",
+            "mcp.tools.list",
+            "mcp.tools.call",
+            "orchestration.trace",
+            "orchestration.graph",
+            "orchestration.steps",
+            "orchestration.routes",
+            "workflow.graph",
+            "streaming.trace",
+            "streaming.events",
+            "streaming.export",
+            "world.contract",
+            "world.state",
+            "world.transitions",
+            "world.invariants",
+            "browser.actions",
+            "agent.trust_boundary",
+            "agent.control_plane",
+            "autonomy.control_plane",
+            "framework.trust_boundary",
+            "framework.control_plane",
+            "security.trust_boundary",
+            "policy.control_plane",
+            "policy.action_gates",
+            "policy.rollback",
+            "policy.kill_switch",
+            "policy.circuit_breakers",
+            "policy.rate_limits",
+            "policy.risk_budgets",
+            "security.containment",
+            "tools.risk_scoring",
+            "tools.action_policy",
+            "security.permissions",
+            "security.sandbox",
+            "security.audit",
+            "security.canaries",
+            "security.network_egress",
+            "policy.approvals",
+            "tools.risk_scoring",
+            "tools.action_policy",
+            "tools.permissions",
+            "tools.allowlist",
+            "memory.isolation",
+            "evaluation.agent_trust_boundary_quality",
+            "evaluation.agent_control_plane_quality",
+            "security.attack_pack",
+            "red_team.campaign",
+            "red_team.taxonomies",
+            "red_team.attack_packs",
+            "red_team.matrix_evidence",
+            "red_team.coverage_matrix",
+            "red_team.matrix_cells",
+            "red_team.scenarios",
+            "red_team.scenarios.matrix_cell_ids",
+            "red_team.runs",
+            "red_team.runs.matrix_cell_ids",
+            "red_team.runs.execution_evidence",
+            "red_team.findings",
+            "red_team.findings.matrix_cell_ids",
+            "red_team.artifacts",
+            "red_team.artifacts.matrix_cell_ids",
+            "red_team.artifacts.execution_evidence",
+            "red_team.mitigations",
+            "red_team.mitigations.matrix_cell_ids",
+            "red_team.channels",
+            "red_team.providers",
+            "red_team.multi_turn",
+            "red_team.preflight",
+            "red_team.readiness",
+            "red_team.readiness.matrix_evidence",
+            "red_team.readiness.framework_import",
+            "red_team.readiness.campaign",
+            "red_team.readiness.workspace_run",
+            "red_team.readiness.trust_boundary",
+            "red_team.readiness.control_plane",
+            "red_team.readiness.observability",
+            "red_team.readiness.artifacts",
+            "adversarial.attacks",
+            "adversarial.surfaces",
+            "observability.replay",
+            "observability.replay_pack",
+            "observability.regression_pack",
+            "futureagi.regression_replay",
+            "evaluation.observability_replay",
+            "evaluation.framework_runtime_contract",
+            "evaluation.framework_import_quality",
+            "evaluation.red_team_readiness",
+            "evaluation.red_team_readiness_quality",
+            "evaluation.red_team_campaign_quality.require_attack_surface_matrix",
+            "evaluation.red_team_campaign_quality.require_run_artifacts",
+            "evaluation.red_team_campaign_quality.require_executed_run_evidence",
+            "evaluation.red_team_campaign_quality.require_finding_mapping",
+            "evaluation.red_team_campaign_quality.require_mitigation_mapping",
+            "evaluation.red_team_campaign_quality.required_attack_matrix_cells",
+            "evaluation.framework_lifecycle_quality",
+            "evaluation.framework_capability_quality",
+            "evaluation.framework_probe_quality",
+            "evaluation.framework_portability_quality",
+            "optimizer",
+            "optimizer.trace",
+            "optimizer.society_trace",
+            "optimizer.strategy",
+            "optimizer.max_rounds",
+            "optimizer.roles",
+            "optimizer.role_graph",
+            "optimizer.proposals",
+            "optimizer.credit",
+            "optimizer.diagnostics",
+            "optimizer.governance",
+            "optimizer.governance.checks",
+            "optimizer.governance.role_diversity",
+            "optimizer.governance.mediator",
+            "optimizer.governance.contract_gate",
+            "optimizer.governance.rollback",
+            "optimizer.governance.search_locality",
+            "optimizer.governance.dependency_audit",
+            "optimizer.backend_portfolio",
+            "optimizer.backends",
+            "optimizer.backend_selector",
+            "optimizer.backend_selector.policy",
+            "optimizer.backend_trials",
+            "optimizer.backend_evidence",
+            "optimizer.portfolio_gate",
+            "optimization",
+            "optimization.target",
+            "optimization.target.search_space",
+            "optimization.optimizer",
+            "optimization.optimizer.max_candidates",
+            "manifest_optimization",
+            "optimization.manifest_optimization",
+            "evaluation.optimizer_portfolio",
+            "evaluation.optimizer_portfolio_quality",
+            "evaluation.optimizer_portfolio_quality.required_backends",
+            "evaluation.optimizer_portfolio_quality.required_evidence",
+            "evaluation.optimizer_portfolio_quality.required_selection_relations",
+            "evaluation.optimizer_portfolio_quality.required_consensus_backends",
+            "evaluation.optimizer_portfolio_quality.required_dependencies",
+            "evaluation.optimizer_portfolio_quality.min_backend_plan_count",
+            "evaluation.optimizer_portfolio_quality.min_backend_run_count",
+            "evaluation.optimizer_portfolio_quality.min_completed_backends",
+            "evaluation.optimizer_portfolio_quality.min_lineage_count",
+            "evaluation.optimizer_portfolio_quality.min_consensus_backends",
+            "evaluation.optimizer_portfolio_quality.max_failed_backends",
+            "evaluation.optimizer_portfolio_quality.min_final_score",
+            "evaluation.optimizer_trace_quality",
+            "evaluation.optimizer_trace_quality.required_roles",
+            "evaluation.optimizer_trace_quality.required_search_paths",
+            "evaluation.optimizer_trace_quality.required_governance_signals",
+            "evaluation.optimizer_trace_quality.min_governance_checks",
+            "evaluation.manifest_optimization",
+            "evaluation.manifest_optimization_quality",
+            "evaluation.manifest_optimization_quality.required_search_paths",
+            "evaluation.manifest_optimization_quality.required_metrics",
+        ],
+        metrics=["reproducibility", "coverage", "pass_at_k", "trial_reliability", "tool_fault_tolerance", "observability_replay_coverage", "observability_replay_quality", "agent_integration_coverage", "agent_integration_quality", "optimizer_trace_coverage", "optimizer_trace_quality", "optimizer_portfolio_coverage", "optimizer_portfolio_quality", "manifest_optimization_coverage", "manifest_optimization_quality", "framework_import_coverage", "framework_import_quality", "red_team_readiness_coverage", "red_team_readiness_quality", "framework_trace_coverage", "framework_adapter_conformance", "framework_runtime_coverage", "framework_runtime_contract", "framework_lifecycle_coverage", "framework_lifecycle_quality", "framework_capability_coverage", "framework_capability_quality", "framework_probe_coverage", "framework_probe_quality", "framework_portability_coverage", "framework_portability_quality", "agent_trust_boundary_coverage", "agent_trust_boundary_quality", "agent_control_plane_coverage", "agent_control_plane_quality", "framework_transcript_quality", "orchestration_trace_coverage", "orchestration_flow_quality", "streaming_trace_coverage", "streaming_interaction_quality", "world_contract_coverage", "world_contract_quality", "adversarial_resilience", "cross_trial_memory_skill", "browser_action_outcome", "browser_grounding_quality"],
+        failure_modes=["environment_mismatch", "evaluation_gap", "integration_gap", "framework_trace_gap", "framework_lifecycle_gap", "framework_capability_gap", "framework_probe_gap", "framework_portability_gap", "trust_boundary_gap", "control_plane_gap", "framework_transcript_gap", "orchestration_trace_gap", "orchestration_flow_failure", "streaming_trace_gap", "streaming_interaction_failure", "world_contract_gap", "world_contract_violation", "adversarial_resilience_failure", "cross_trial_memory_skill_failure", "reliability_failure", "fault_tolerance_failure", "browser_action_failure"],
+        patch_strategies=["add mocks", "stabilize environment", "increase scenario coverage"],
+    ),
+    "integration": AgentComponentSpec(
+        name="integration",
+        config_paths=[
+            "integrations",
+            "agent_integrations",
+            "agent_definition",
+            "agent.definition",
+            "personas",
+            "simulation.personas",
+            "simulation.channels",
+            "simulation.sessions",
+            "simulation.providers",
+            "providers",
+            "providers.livekit",
+            "providers.vapi",
+            "providers.retell",
+            "providers.bland",
+            "providers.elevenlabs",
+            "providers.deepgram",
+            "providers.agora",
+            "providers.pipecat",
+            "providers.twilio",
+            "integrations.livekit",
+            "integrations.livekit.channels",
+            "integrations.livekit.webrtc",
+            "integrations.livekit.sip",
+            "integrations.livekit.phone",
+            "integrations.vapi",
+            "integrations.vapi.chat",
+            "integrations.vapi.voice",
+            "integrations.vapi.webrtc",
+            "integrations.vapi.sip",
+            "integrations.vapi.phone",
+            "integrations.retell",
+            "integrations.retell.chat",
+            "integrations.retell.voice",
+            "integrations.bland",
+            "integrations.bland.voice",
+            "integrations.bland.sip",
+            "integrations.bland.phone",
+            "integrations.bland.web_call",
+            "integrations.elevenlabs",
+            "integrations.deepgram",
+            "integrations.agora",
+            "integrations.pipecat",
+            "integrations.twilio",
+            "integrations.traceai",
+            "traceai.frameworks",
+            "traceai.instrumentors",
+            "traceai.livekit",
+            "traceai.pipecat",
+            "voice.providers",
+            "voice.trace.livekit",
+            "voice.trace.retell",
+            "voice.trace.elevenlabs",
+            "voice.trace.deepgram",
+            "voice.trace.agora",
+            "voice.trace.twilio",
+            "voice.webrtc",
+            "voice.phone",
+            "voice.sip",
+            "streaming.transports",
+            "framework.import_manifest",
+            "framework.import.sources",
+            "framework.import.trace_exports",
+            "framework.import.event_streams",
+            "framework.import.capabilities",
+            "framework.import.probes",
+            "framework.import.portability",
+            "platform.futureagi",
+            "platform.futureagi.ui_loop",
+            "workspace_run",
+            "workspace_run.repository",
+            "workspace_run.checkout",
+            "workspace_run.commands",
+            "workspace_run.logs",
+            "workspace_run.artifacts",
+            "workspace_run.simulations",
+            "workspace_run.evals",
+            "workspace_run.optimization",
+            "workspace_run.red_team",
+            "workspace_run.security",
+            "workspace_run.ui_verification",
+            "workspace_run.observability",
+            "github.app_installation",
+            "github.repository_access",
+            "execution.checkout",
+            "execution.commands",
+            "execution.logs",
+            "execution.artifacts",
+            "red_team.attack_pack",
+            "red_team.campaign",
+            "red_team.taxonomies",
+            "red_team.matrix_evidence",
+            "red_team.coverage_matrix",
+            "red_team.matrix_cells",
+            "red_team.scenarios",
+            "red_team.scenarios.matrix_cell_ids",
+            "red_team.runs",
+            "red_team.runs.matrix_cell_ids",
+            "red_team.runs.execution_evidence",
+            "red_team.findings",
+            "red_team.findings.matrix_cell_ids",
+            "red_team.artifacts",
+            "red_team.artifacts.matrix_cell_ids",
+            "red_team.artifacts.execution_evidence",
+            "red_team.mitigations",
+            "red_team.mitigations.matrix_cell_ids",
+            "red_team.multi_turn",
+            "red_team.owasp_llm_top_10",
+            "red_team.owasp_agentic_ai",
+            "red_team.mcp_security",
+            "red_team.garak",
+            "red_team.pyrit",
+            "red_team.inspect",
+            "red_team.preflight",
+            "red_team.readiness",
+            "red_team.readiness.matrix_evidence",
+            "red_team.readiness.framework_import",
+            "red_team.readiness.campaign",
+            "red_team.readiness.workspace_run",
+            "red_team.readiness.trust_boundary",
+            "red_team.readiness.control_plane",
+            "red_team.readiness.observability",
+            "red_team.readiness.artifacts",
+            "security.sandbox",
+            "security.secret_redaction",
+            "security.policy_gates",
+            "observability.futureagi",
+            "observability.traces",
+            "observability.webhooks",
+            "evaluation.agent_integration",
+            "evaluation.agent_integration_quality",
+            "evaluation.workspace_run",
+            "evaluation.workspace_run_quality",
+            "evaluation.red_team_campaign",
+            "evaluation.red_team_campaign_quality",
+            "evaluation.red_team_campaign_quality.require_attack_surface_matrix",
+            "evaluation.red_team_campaign_quality.require_run_artifacts",
+            "evaluation.red_team_campaign_quality.require_executed_run_evidence",
+            "evaluation.red_team_campaign_quality.require_finding_mapping",
+            "evaluation.red_team_campaign_quality.require_mitigation_mapping",
+            "evaluation.red_team_campaign_quality.required_attack_matrix_cells",
+            "evaluation.red_team_readiness",
+            "evaluation.red_team_readiness_quality",
+            "evaluation.framework_import",
+            "evaluation.framework_import_quality",
+            "futureagi.evals",
+            "futureagi.observability",
+        ],
+        metrics=[
+            "agent_integration_coverage",
+            "agent_integration_quality",
+            "workspace_run_coverage",
+            "workspace_run_quality",
+            "red_team_campaign_coverage",
+            "red_team_campaign_quality",
+            "red_team_readiness_coverage",
+            "red_team_readiness_quality",
+            "voice_trace_coverage",
+            "voice_interaction_quality",
+            "streaming_trace_coverage",
+            "streaming_interaction_quality",
+            "framework_import_coverage",
+            "framework_import_quality",
+            "framework_trace_coverage",
+            "framework_runtime_contract",
+            "observability_replay_coverage",
+            "observability_replay_quality",
+        ],
+        failure_modes=[
+            "integration_gap",
+            "voice_turn_taking_failure",
+            "streaming_trace_gap",
+            "streaming_interaction_failure",
+            "framework_trace_gap",
+            "evaluation_gap",
+            "environment_mismatch",
+        ],
+        patch_strategies=["add provider/channel manifest", "attach Future AGI observability and eval hooks"],
+    ),
+    "framework": AgentComponentSpec(
+        name="framework",
+        config_paths=[
+            "framework",
+            "framework.adapter",
+            "framework.adapter.required_signals",
+            "framework.adapter.mappings",
+            "framework.import_manifest",
+            "framework.import.sources",
+            "framework.import.required_frameworks",
+            "framework.import.required_export_types",
+            "framework.import.required_signals",
+            "framework.import.trace_exports",
+            "framework.import.event_streams",
+            "framework.import.lifecycle",
+            "framework.import.capabilities",
+            "framework.import.probes",
+            "framework.import.portability",
+            "framework.import.observability",
+            "framework.import.artifacts",
+            "framework.capabilities",
+            "framework.capabilities.required",
+            "framework.capabilities.task_surfaces",
+            "framework.capabilities.tools",
+            "framework.capabilities.memory",
+            "framework.capabilities.streaming",
+            "framework.capabilities.lifecycle",
+            "framework.capabilities.orchestration",
+            "framework.capabilities.security",
+            "framework.capabilities.observability",
+            "framework.capabilities.exports",
+            "framework.probes",
+            "framework.probes.required_operations",
+            "framework.probes.invoke",
+            "framework.probes.tools",
+            "framework.probes.memory",
+            "framework.probes.streaming",
+            "framework.probes.lifecycle",
+            "framework.probes.orchestration",
+            "framework.probes.security",
+            "framework.probes.observability",
+            "framework.probes.exports",
+            "framework.portability",
+            "framework.portability.source",
+            "framework.portability.target",
+            "framework.portability.mappings",
+            "framework.portability.tools",
+            "framework.portability.memory",
+            "framework.portability.streaming",
+            "framework.portability.lifecycle",
+            "framework.portability.orchestration",
+            "framework.portability.security",
+            "framework.portability.observability",
+            "framework.portability.exports",
+            "framework.portability.browser",
+            "framework.portability.voice",
+            "framework.portability.runtime",
+            "framework.trust_boundary",
+            "framework.trust_boundary.actors",
+            "framework.trust_boundary.assets",
+            "framework.trust_boundary.tools",
+            "framework.trust_boundary.surfaces",
+            "framework.trust_boundary.controls",
+            "framework.trust_boundary.threats",
+            "framework.security.trust_boundary",
+            "agent.trust_boundary",
+            "framework.control_plane",
+            "framework.control_plane.actions",
+            "framework.control_plane.controls",
+            "framework.control_plane.budgets",
+            "framework.control_plane.escalations",
+            "framework.control_plane.incidents",
+            "framework.runtime.control_plane",
+            "agent.control_plane",
+            "framework.runtime",
+            "framework.runtime.method",
+            "framework.runtime.input_mode",
+            "framework.runtime.output_schema",
+            "framework.runtime.trace_runtime",
+            "framework.runtime.contract",
+            "framework.lifecycle",
+            "framework.lifecycle.phases",
+            "framework.lifecycle.sessions",
+            "framework.lifecycle.setup",
+            "framework.lifecycle.tool_registration",
+            "framework.lifecycle.checkpoints",
+            "framework.lifecycle.retry_policy",
+            "framework.lifecycle.cancel_resume",
+            "framework.lifecycle.cleanup",
+            "framework.trace",
+            "framework.trace.export",
+            "framework.trace.export_source",
+            "framework.trace.export.auth",
+            "framework.trace.export.pagination",
+            "framework.trace.export.cursor",
+            "framework.trace.export.page_size",
+            "framework.trace.collectors",
+            "framework.trace.otlp",
+            "framework.memory",
+            "framework.checkpoints",
+            "framework.checkpoints.state",
+            "framework.checkpoints.parent",
+            "framework.sessions",
+            "framework.sessions.thread_id",
+            "framework.sessions.thread_id_source",
+            "framework.spans",
+            "framework.events",
+            "framework.event_stream",
+            "framework.streaming",
+            "framework.stream_events",
+            "framework.transcript",
+            "framework.transcript.speakers",
+            "framework.transcript.handoffs",
+            "framework.transcript.termination",
+            "framework.transcript.tool_owners",
+            "orchestration.trace",
+            "orchestration.trace.export",
+            "orchestration.graph",
+            "orchestration.nodes",
+            "orchestration.edges",
+            "orchestration.steps",
+            "workflow.events",
+            "workflow.graph",
+            "optimizer",
+            "optimizer.strategy",
+            "optimizer.max_rounds",
+            "optimizer.society",
+            "optimizer.roles",
+            "optimizer.role_graph",
+            "optimizer.proposals",
+            "optimizer.credit",
+            "optimizer.diagnostics",
+            "workflow.nodes",
+            "workflow.edges",
+            "autogen.groupchat",
+            "crewai.events",
+            "openai_agents.sessions",
+            "openai_agents.tracing",
+            "langchain.stream_events",
+            "langchain.streaming",
+            "langgraph.stream_events",
+            "langgraph.streaming",
+            "langgraph.checkpointer",
+            "langgraph.checkpointer.enabled",
+            "langgraph.checkpointer.store",
+            "langgraph.nodes",
+            "mcp",
+            "mcp.server",
+            "mcp.tool_session",
+            "mcp.tools.list",
+            "mcp.tools.schema",
+            "mcp.tools.call",
+            "mcp.tools.result",
+            "mcp.tools.error",
+            "mcp.resources",
+            "openai_agents.streaming",
+            "openai_agents.stream_events",
+            "livekit.session_events",
+            "pipecat.frames",
+            "instrumentation",
+            "otel",
+            "otel.gen_ai.streaming",
+            "otlp",
+            "traceai",
+            "futureagi.traces",
+            "futureagi.regression_replay",
+            "runtime.tracing",
+            "simulation.framework",
+        ],
+        metrics=["framework_import_coverage", "framework_import_quality", "framework_trace_coverage", "framework_adapter_conformance", "framework_runtime_coverage", "framework_runtime_contract", "framework_lifecycle_coverage", "framework_lifecycle_quality", "framework_capability_coverage", "framework_capability_quality", "framework_probe_coverage", "framework_probe_quality", "framework_portability_coverage", "framework_portability_quality", "agent_trust_boundary_coverage", "agent_trust_boundary_quality", "agent_control_plane_coverage", "agent_control_plane_quality", "framework_transcript_quality", "observability_replay_coverage", "observability_replay_quality", "orchestration_trace_coverage", "orchestration_flow_quality", "streaming_trace_coverage", "streaming_interaction_quality", "cross_trial_memory_skill", "runtime_success", "schema_validity"],
+        failure_modes=["framework_trace_gap", "framework_lifecycle_gap", "framework_capability_gap", "framework_probe_gap", "framework_portability_gap", "trust_boundary_gap", "control_plane_gap", "framework_transcript_gap", "orchestration_trace_gap", "orchestration_flow_failure", "streaming_trace_gap", "streaming_interaction_failure", "cross_trial_memory_skill_failure", "implementation_bug", "evaluation_gap"],
+        patch_strategies=["enable framework tracing", "normalize framework spans and event streams"],
+    ),
+    "orchestration": AgentComponentSpec(
+        name="orchestration",
+        config_paths=[
+            "orchestration",
+            "orchestration.trace",
+            "orchestration.trace.export",
+            "orchestration.graph",
+            "orchestration.nodes",
+            "orchestration.edges",
+            "orchestration.routes",
+            "orchestration.steps",
+            "orchestration.retries",
+            "orchestration.recovery",
+            "orchestration.budgets",
+            "workflow",
+            "workflow.graph",
+            "workflow.nodes",
+            "workflow.edges",
+            "workflow.routes",
+            "workflow.retry_policy",
+            "workflow.timeout",
+            "graph",
+            "graph.nodes",
+            "graph.edges",
+            "graph.retry_policy",
+            "langgraph.routing",
+            "langgraph.retry_policy",
+            "livekit.fallbacks",
+            "pipecat.pipeline",
+        ],
+        metrics=[
+            "orchestration_trace_coverage",
+            "orchestration_flow_quality",
+            "framework_trace_coverage",
+            "framework_transcript_quality",
+            "trial_reliability",
+            "tool_fault_tolerance",
+            "latency",
+            "cost",
+        ],
+        failure_modes=[
+            "orchestration_trace_gap",
+            "orchestration_flow_failure",
+            "framework_trace_gap",
+            "framework_transcript_gap",
+            "latency_or_cost",
+            "coordination_failure",
+            "fault_tolerance_failure",
+            "reliability_failure",
+        ],
+        patch_strategies=["capture workflow graph traces", "tune routing, retries, recovery, and budgets"],
+    ),
+    "streaming": AgentComponentSpec(
+        name="streaming",
+        config_paths=[
+            "streaming",
+            "streaming.trace",
+            "streaming.export",
+            "streaming.events",
+            "streaming.chunks",
+            "streaming.tool_deltas",
+            "streaming.interruptions",
+            "streaming.finalization",
+            "streaming.buffer",
+            "streaming.backpressure",
+            "streaming.latency",
+            "streaming.gap",
+            "streaming.usage",
+            "runtime.streaming",
+            "runtime.event_stream",
+            "framework.streaming",
+            "framework.stream_events",
+            "framework.event_stream",
+            "framework.lifecycle",
+            "framework.lifecycle.cancel_resume",
+            "langchain.streaming",
+            "langchain.stream_events",
+            "langgraph.streaming",
+            "langgraph.stream_events",
+            "openai_agents.streaming",
+            "openai_agents.stream_events",
+            "livekit.session_events",
+            "livekit.interruptions",
+            "pipecat.frames",
+            "pipecat.pipeline",
+            "otel.gen_ai.streaming",
+            "simulation.streaming",
+        ],
+        metrics=[
+            "streaming_trace_coverage",
+            "streaming_interaction_quality",
+            "latency",
+            "runtime_success",
+            "framework_trace_coverage",
+            "framework_lifecycle_quality",
+            "voice_interaction_quality",
+        ],
+        failure_modes=[
+            "streaming_trace_gap",
+            "streaming_interaction_failure",
+            "latency_or_cost",
+            "framework_trace_gap",
+            "framework_lifecycle_gap",
+            "voice_turn_taking_failure",
+            "implementation_bug",
+            "evaluation_gap",
+        ],
+        patch_strategies=["capture stream events", "tune chunk assembly, buffering, interruption recovery, and finalization"],
+    ),
+    "world": AgentComponentSpec(
+        name="world",
+        config_paths=[
+            "world",
+            "world.contract",
+            "world.actors",
+            "world.resources",
+            "world.state",
+            "world.initial_state",
+            "world.transitions",
+            "world.required_transitions",
+            "world.forbidden_transitions",
+            "world.invariants",
+            "world.success_conditions",
+            "world.policy_gates",
+            "world.adversarial_surfaces",
+            "world.milestones",
+            "environment.world",
+            "environment.contract",
+            "environment.state",
+            "simulation.world",
+            "simulation.environment",
+            "tools.state_updates",
+            "policy.world_rules",
+        ],
+        metrics=[
+            "world_contract_coverage",
+            "world_contract_quality",
+            "state_goal_accuracy",
+            "tool_outcome",
+            "tool_fault_tolerance",
+            "trial_reliability",
+            "environment_injection_resistance",
+        ],
+        failure_modes=[
+            "world_contract_gap",
+            "world_contract_violation",
+            "environment_mismatch",
+            "policy_violation",
+            "tool_execution_error",
+            "fault_tolerance_failure",
+            "reliability_failure",
+            "evaluation_gap",
+        ],
+        patch_strategies=["add world contract state machine", "tune transitions, invariants, policy gates, and success conditions"],
+    ),
+    "security": AgentComponentSpec(
+        name="security",
+        config_paths=[
+            "security",
+            "security.attack_pack",
+            "security.trust_boundary",
+            "security.trust_boundaries",
+            "security.control_plane",
+            "security.risk_scoring",
+            "security.kill_switch",
+            "security.circuit_breakers",
+            "security.rate_limits",
+            "security.risk_budgets",
+            "security.containment",
+            "security.drift_detection",
+            "security.identity",
+            "security.permissions",
+            "security.sandbox",
+            "security.audit",
+            "security.canaries",
+            "security.human_approval",
+            "security.network_egress",
+            "security.tool_allowlist",
+            "security.data_boundary",
+            "security.secret_handling",
+            "security.untrusted_context",
+            "security.canaries",
+            "security.blocked_tools",
+            "security.tool_permissions",
+            "security.prompt_injection",
+            "security.output_filter",
+            "security.approval_gate",
+            "security.data_loss_prevention",
+            "guardrails",
+            "policy.guardrails",
+            "policy.trust_boundary",
+            "policy.approvals",
+            "policy.untrusted_context",
+            "policy.blocked_tools",
+            "tools.permissions",
+            "tools.allowlist",
+            "memory.write_policy",
+            "memory.write_quarantine",
+            "memory.isolation",
+            "memory.untrusted_context",
+            "memory.provenance",
+            "memory.trust_labels",
+            "memory.rehydration_policy",
+            "memory.lineage.poison_tests",
+            "memory.lineage.tenant_isolation",
+            "memory.lineage.canaries",
+            "security.memory_poisoning",
+            "security.persistent_state_attack",
+            "security.stored_prompt_injection",
+            "security.memory_lineage",
+            "security.memory_isolation",
+            "browser.injection_surfaces",
+            "environment.adversarial",
+            "environment.red_team_campaign",
+            "adversarial.attacks",
+            "adversarial.canaries",
+            "red_team.campaign",
+            "red_team.taxonomies",
+            "red_team.attack_packs",
+            "red_team.scenarios",
+            "red_team.runs",
+            "red_team.findings",
+            "red_team.artifacts",
+            "red_team.mitigations",
+            "red_team.channels",
+            "red_team.providers",
+            "red_team.multi_turn",
+            "red_team.owasp_llm_top_10",
+            "red_team.owasp_agentic_ai",
+            "red_team.mcp_security",
+            "red_team.garak",
+            "red_team.pyrit",
+            "red_team.inspect",
+            "red_team.preflight",
+            "red_team.readiness",
+            "red_team.readiness.framework_import",
+            "red_team.readiness.campaign",
+            "red_team.readiness.workspace_run",
+            "red_team.readiness.trust_boundary",
+            "red_team.readiness.control_plane",
+            "red_team.readiness.observability",
+            "red_team.readiness.artifacts",
+            "persistent_state_attack",
+            "persistent_state_attack.write_policy",
+            "persistent_state_attack.context_rehydration",
+            "persistent_state_attack.activation_guard",
+            "persistent_state_attack.provenance",
+        ],
+        metrics=[
+            "adversarial_resilience",
+            "persistent_state_attack_coverage",
+            "persistent_state_attack_quality",
+            "red_team_campaign_coverage",
+            "red_team_campaign_quality",
+            "red_team_readiness_coverage",
+            "red_team_readiness_quality",
+            "environment_injection_resistance",
+            "prompt_injection_resistance",
+            "secret_leakage",
+            "memory_integrity",
+            "agent_memory_lineage_quality",
+            "policy_adherence",
+            "action_safety",
+            "trajectory_browser_action_safety",
+            "agent_trust_boundary_coverage",
+            "agent_trust_boundary_quality",
+            "agent_control_plane_coverage",
+            "agent_control_plane_quality",
+        ],
+        failure_modes=[
+            "trust_boundary_gap",
+            "control_plane_gap",
+            "adversarial_resilience_failure",
+            "policy_violation",
+            "unsafe_action",
+            "memory_contamination",
+            "environment_mismatch",
+            "evaluation_gap",
+        ],
+        patch_strategies=["quarantine untrusted context", "enforce tool allowlists, canary filters, and approval gates"],
+    ),
+    "perception": AgentComponentSpec(
+        name="perception",
+        config_paths=[
+            "perception",
+            "artifacts",
+            "artifact_grounding",
+            "artifact_semantics",
+            "structured_artifacts",
+            "multimodal",
+            "vision",
+            "audio",
+            "trajectory.multimodal",
+            "browser.dom",
+            "browser.trace",
+            "browser.trace.har",
+            "browser.trace.openai_cua",
+            "browser.trace.browser_use",
+            "browser.resources",
+            "browser.resource_bodies",
+            "browser.actionability",
+            "browser.storage_state",
+            "browser.cookies",
+            "browser.local_storage",
+            "browser.session_storage",
+            "browser.runtime",
+            "browser.runtime_events",
+            "browser.performance_entries",
+            "browser.performance_timing",
+            "browser.regions",
+            "browser.screenshot_diff",
+            "browser.screenshot_diff.pixel",
+            "browser.screenshot_diff.semantic",
+            "browser.screenshot_diff.mask",
+            "browser.semantic_regions",
+            "browser.masked_regions",
+            "browser.allowed_regions",
+            "browser.forbidden_regions",
+            "browser.pixel_diff",
+            "browser.layout_shift_distribution",
+            "simulation.environment",
+            "environment.images",
+            "environment.voice",
+            "voice.trace",
+            "voice.webrtc",
+            "voice.webrtc.stats",
+            "voice.webrtc.get_stats",
+            "voice.webrtc.rtp",
+            "voice.webrtc.track",
+            "voice.webrtc.codec",
+            "voice.timing_distribution",
+        ],
+        metrics=[
+            "grounding_accuracy",
+            "ocr_accuracy",
+            "audio_transcription_quality",
+            "artifact_coverage",
+            "artifact_semantics_quality",
+            "browser_trace_coverage",
+            "browser_action_outcome",
+            "browser_grounding_quality",
+            "voice_trace_coverage",
+            "voice_timing_distribution_quality",
+            "multimodal_faithfulness",
+            "artifact_grounding_quality",
+        ],
+        failure_modes=[
+            "perception_grounding_failure",
+            "artifact_semantics_failure",
+            "voice_turn_taking_failure",
+            "voice_timing_distribution_failure",
+            "browser_action_failure",
+        ],
+        patch_strategies=["improve artifact capture", "add multimodal grounding checks"],
+    ),
+    "prompt": AgentComponentSpec(
+        name="prompt",
+        config_paths=["prompt", "instructions", "system_prompt", "trajectory.policy"],
+        metrics=["instruction_following", "final_response_quality", "agent_goal_accuracy", "policy_adherence", "source_contradiction"],
+        failure_modes=["unclear_goal", "poor_plan", "hallucination", "policy_violation"],
+        patch_strategies=["rewrite role/task instructions", "add constraints/examples"],
+    ),
+    "planner": AgentComponentSpec(
+        name="planner",
+        config_paths=["planner", "planning", "graph.plan", "graph.nodes", "graph.edges", "workflow.graph", "workflow.nodes", "workflow.edges", "orchestration.steps", "orchestration.routes", "trajectory", "trajectory.steps", "framework.transcript.tool_sequence", "langgraph.nodes", "optimizer.trace", "optimizer.society_trace", "optimizer.roles", "optimizer.role_graph", "optimizer.proposals", "optimizer.credit", "optimizer.governance", "optimizer.backend_selector", "optimizer.backend_selector.policy", "optimizer.portfolio_gate", "optimization", "optimization.target.search_space", "optimization.optimizer.max_candidates"],
+        metrics=["plan_validity", "trajectory_accuracy", "step_success", "trial_reliability", "agent_goal_accuracy", "tool_call_accuracy", "optimizer_trace_coverage", "optimizer_trace_quality", "optimizer_portfolio_coverage", "optimizer_portfolio_quality", "manifest_optimization_coverage", "manifest_optimization_quality", "framework_transcript_quality", "orchestration_flow_quality"],
+        failure_modes=["poor_plan", "context_overload", "reliability_failure", "framework_transcript_gap", "orchestration_flow_failure"],
+        patch_strategies=["add decomposition", "add self-checks", "limit branching"],
+    ),
+    "autonomy": AgentComponentSpec(
+        name="autonomy",
+        config_paths=[
+            "autonomy",
+            "autonomy.loop",
+            "autonomy.control_plane",
+            "autonomy.action_gates",
+            "autonomy.risk_budgets",
+            "autonomy.rollback",
+            "autonomy.kill_switch",
+            "autonomy.plan",
+            "autonomy.reflection",
+            "autonomy.verifier",
+            "autonomy.memory",
+            "autonomy.skill_library",
+            "autonomy.stop_policy",
+            "planner",
+            "memory",
+            "policy",
+        ],
+        metrics=[
+            "autonomy_loop_coverage",
+            "autonomy_loop_quality",
+            "cross_trial_memory_skill",
+            "plan_validity",
+            "memory_recall",
+            "policy_adherence",
+            "trial_reliability",
+            "agent_control_plane_coverage",
+            "agent_control_plane_quality",
+        ],
+        failure_modes=["autonomy_loop_failure", "control_plane_gap", "cross_trial_memory_skill_failure", "poor_plan", "memory_retrieval_failure", "reliability_failure"],
+        patch_strategies=["add observe-orient-plan-act-verify-reflect loop evidence"],
+    ),
+    "router": AgentComponentSpec(
+        name="router",
+        config_paths=["router", "model_router", "tool_router", "memory.router", "workflow.routing", "workflow.routes", "orchestration.routes", "orchestration.edges", "graph.edges", "langgraph.routing", "framework.transcript.nodes"],
+        metrics=["routing_accuracy", "latency", "cost", "framework_transcript_quality", "orchestration_flow_quality"],
+        failure_modes=["wrong_tool", "latency_or_cost", "context_overload", "framework_transcript_gap", "orchestration_flow_failure"],
+        patch_strategies=["add intent classifier", "route by task/tool/context"],
+    ),
+    "tools": AgentComponentSpec(
+        name="tools",
+        config_paths=[
+            "tools",
+            "tool_schemas",
+            "mcp",
+            "mcp.server",
+            "mcp.tool_session",
+            "mcp.tools.list",
+            "mcp.tools.schema",
+            "mcp.tools.call",
+            "mcp.tools.result",
+            "mcp.tools.error",
+            "functions",
+            "tools.risk_scoring",
+            "tools.action_policy",
+            "tools.permissions",
+            "tools.allowlist",
+            "tools.blocklist",
+            "tools.auth",
+            "tools.high_risk",
+            "tools.external",
+            "tools.destructive",
+            "tools.argument_builder",
+            "tools.result_mapper",
+            "framework.portability.tools",
+            "framework.portability.mappings",
+            "trajectory.tools",
+            "trajectory.tool_order",
+            "framework.lifecycle.tool_registration",
+            "framework.transcript.tool_sequence",
+            "orchestration.steps",
+            "orchestration.retries",
+            "workflow.retry_policy",
+        ],
+        metrics=["tool_selection_accuracy", "slot_filling_accuracy", "tool_success", "tool_argument_schema", "tool_outcome", "tool_fault_tolerance", "adversarial_resilience", "agent_trust_boundary_coverage", "agent_trust_boundary_quality", "agent_control_plane_coverage", "agent_control_plane_quality", "trial_reliability", "tool_call_accuracy", "tool_call_f1", "framework_lifecycle_quality", "framework_portability_quality", "framework_transcript_quality", "orchestration_flow_quality"],
+        failure_modes=["wrong_tool", "bad_tool_arguments", "tool_execution_error", "missing_tool", "adversarial_resilience_failure", "trust_boundary_gap", "control_plane_gap", "reliability_failure", "fault_tolerance_failure", "framework_lifecycle_gap", "framework_portability_gap", "framework_transcript_gap", "orchestration_flow_failure"],
+        patch_strategies=["rewrite descriptions", "tighten schemas", "add tool mocks"],
+    ),
+    "memory": AgentComponentSpec(
+        name="memory",
+        config_paths=["memory", "memory.cross_trial", "memory.recall_policy", "memory.persistence", "memory.state_persistence", "memory.checkpoint_state", "memory.checkpoint_lineage", "memory.lineage", "memory.lineage.stores", "memory.lineage.memories", "memory.lineage.operations", "memory.lineage.source_attribution", "memory.lineage.tenant_isolation", "memory.lineage.audit", "memory.lineage.retention", "memory.lineage.deletion", "memory.lineage.redaction", "memory.lineage.canaries", "memory.lineage.poison_tests", "memory.lineage.observability", "memory.write_policy", "memory.write_quarantine", "memory.isolation", "memory.untrusted_context", "memory.provenance", "memory.trust_labels", "memory.rehydration_policy", "memory.control_plane", "memory.audit", "memory.drift_detection", "persistent_state_attack", "persistent_state_attack.write_policy", "persistent_state_attack.context_rehydration", "persistent_state_attack.activation_guard", "persistent_state_attack.provenance", "state", "scratchpad", "episodic_memory", "memory.attribution", "memory.correctness", "trajectory.memory", "framework.memory", "framework.portability.memory", "framework.portability.lifecycle", "framework.checkpoints", "framework.checkpoints.state", "framework.sessions", "framework.sessions.thread_id", "framework.lifecycle.sessions", "framework.lifecycle.checkpoints", "framework.lifecycle.resume", "framework.lifecycle.state_persistence", "framework.transcript.state", "orchestration.state", "orchestration.checkpoints", "workflow.state", "sessions"],
+        metrics=["memory_precision", "memory_recall", "cross_trial_memory_skill", "supportedness", "retrieval_memory_attribution", "agent_memory_lineage_coverage", "agent_memory_lineage_quality", "retrieval_context_quality", "source_grounding", "source_contradiction", "adversarial_resilience", "persistent_state_attack_coverage", "persistent_state_attack_quality", "agent_trust_boundary_coverage", "agent_trust_boundary_quality", "agent_control_plane_coverage", "agent_control_plane_quality", "trial_reliability", "memory_correctness", "framework_lifecycle_quality", "framework_portability_quality", "framework_transcript_quality", "orchestration_flow_quality"],
+        failure_modes=[
+            "memory_write_failure",
+            "memory_retrieval_failure",
+            "memory_contamination",
+            "adversarial_resilience_failure",
+            "trust_boundary_gap",
+            "control_plane_gap",
+            "cross_trial_memory_skill_failure",
+            "context_overload",
+            "reliability_failure",
+            "framework_lifecycle_gap",
+            "framework_portability_gap",
+            "framework_transcript_gap",
+            "orchestration_flow_failure",
+        ],
+        patch_strategies=["change write policy", "change retrieval tier", "summarize/forget"],
+    ),
+    "retrieval": AgentComponentSpec(
+        name="retrieval",
+        config_paths=["retrieval", "retriever", "rag", "knowledge", "citations", "attribution"],
+        metrics=["context_relevance", "faithfulness", "groundedness", "retrieval_memory_attribution", "retrieval_context_quality", "source_grounding", "source_contradiction"],
+        failure_modes=["retrieval_relevance_failure", "hallucination"],
+        patch_strategies=["change retriever/reranker", "tighten chunking", "add citations"],
+    ),
+    "policy": AgentComponentSpec(
+        name="policy",
+        config_paths=["policy", "guardrails", "constraints", "safety", "trajectory.policy", "policy.trust_boundary", "policy.control_plane", "policy.action_gates", "policy.permissions", "policy.approvals", "policy.rollback", "policy.kill_switch", "policy.circuit_breakers", "policy.rate_limits", "policy.risk_budgets", "policy.data_boundary", "policy.secret_handling", "policy.network_egress", "policy.untrusted_context", "policy.blocked_tools", "policy.canary_filter", "policy.memory_lineage", "policy.memory_source_attribution", "policy.memory_tenant_isolation", "policy.memory_retention", "policy.memory_deletion", "policy.memory_redaction", "policy.persistent_state_attack", "policy.persistent_state_write_gate", "policy.context_rehydration", "policy.activation_guard", "security.guardrails"],
+        metrics=["policy_adherence", "risk_score", "unsafe_action_rate", "adversarial_resilience", "persistent_state_attack_quality", "agent_memory_lineage_quality", "agent_trust_boundary_coverage", "agent_trust_boundary_quality", "agent_control_plane_coverage", "agent_control_plane_quality", "tool_fault_tolerance", "trial_reliability", "trajectory_browser_action_safety"],
+        failure_modes=["policy_violation", "unsafe_action", "adversarial_resilience_failure", "trust_boundary_gap", "control_plane_gap", "reliability_failure", "fault_tolerance_failure"],
+        patch_strategies=["add explicit decision gates", "block irreversible actions"],
+    ),
+    "action": AgentComponentSpec(
+        name="action",
+        config_paths=["action", "executor", "actuator", "trajectory.browser"],
+        metrics=["action_success", "invalid_action_rate", "tool_outcome", "tool_fault_tolerance", "browser_action_outcome", "browser_grounding_quality", "trajectory_browser_action_safety"],
+        failure_modes=["unsafe_action", "tool_execution_error", "schema_error", "fault_tolerance_failure", "browser_action_failure"],
+        patch_strategies=["validate actions", "add retry/state observations"],
+    ),
+    "environment": AgentComponentSpec(
+        name="environment",
+        config_paths=["environment", "fixtures", "mocks", "state", "environment.world", "environment.contract", "environment.agent_integration", "environment.integrations", "environment.agent_trust_boundary", "environment.trust_boundary", "environment.agent_control_plane", "environment.control_plane", "environment.agent_memory_lineage", "environment.memory_lineage", "environment.memory_provenance", "environment.memory_poisoning", "environment.persistent_state_attack", "environment.stored_prompt_injection", "environment.adversarial", "environment.attack_pack", "environment.red_team_campaign", "environment.red_team_readiness", "environment.red_team_preflight", "environment.observability_replay", "environment.replay_pack", "world.contract", "world.state", "world.transitions", "world.invariants", "adversarial.attacks", "adversarial.surfaces", "red_team.campaign", "red_team.readiness", "red_team.preflight", "red_team.scenarios", "red_team.runs", "red_team.artifacts", "red_team.observability", "persistent_state_attack", "persistent_state_attack.lifecycle", "persistent_state_attack.write_policy", "persistent_state_attack.context_rehydration", "persistent_state_attack.activation_guard", "observability.replay", "observability.replay_pack", "futureagi.regression_replay", "environment.structured_artifacts", "structured_artifacts", "environment.domain_packages", "domain_packages"],
+        metrics=["environment_success", "state_goal_accuracy", "agent_memory_lineage_coverage", "agent_memory_lineage_quality", "agent_integration_coverage", "agent_integration_quality", "workspace_run_coverage", "workspace_run_quality", "observability_replay_coverage", "observability_replay_quality", "world_contract_coverage", "world_contract_quality", "adversarial_resilience", "persistent_state_attack_coverage", "persistent_state_attack_quality", "red_team_campaign_coverage", "red_team_campaign_quality", "red_team_readiness_coverage", "red_team_readiness_quality", "agent_trust_boundary_coverage", "agent_trust_boundary_quality", "agent_control_plane_coverage", "agent_control_plane_quality", "tool_outcome", "tool_fault_tolerance", "browser_action_outcome", "browser_grounding_quality", "artifact_semantics_quality", "domain_package_quality"],
+        failure_modes=["environment_mismatch", "integration_gap", "world_contract_gap", "world_contract_violation", "adversarial_resilience_failure", "trust_boundary_gap", "control_plane_gap", "implementation_bug", "fault_tolerance_failure", "browser_action_failure", "artifact_semantics_failure", "domain_package_failure"],
+        patch_strategies=["mock external state", "snapshot/restore environment"],
+    ),
+    "implementation": AgentComponentSpec(
+        name="implementation",
+        config_paths=["implementation", "code", "runtime", "runtime.adapter", "runtime.control_plane", "runtime.integrations", "framework.import_manifest", "framework.import.sources", "framework.runtime.method", "framework.runtime.output_schema", "framework.portability", "framework.portability.mappings", "framework.portability.runtime", "framework.trust_boundary", "framework.control_plane", "security.trust_boundary", "security.control_plane", "framework.lifecycle.setup", "framework.lifecycle.cleanup", "framework.lifecycle.retry_policy", "framework.lifecycle.cancel_resume", "dependencies", "domain_packages.parser", "domain_packages.normalizer"],
+        metrics=["exception_rate", "schema_validity", "runtime_success", "agent_integration_quality", "workspace_run_quality", "framework_import_quality", "framework_runtime_contract", "framework_lifecycle_quality", "framework_portability_quality", "agent_trust_boundary_quality", "agent_control_plane_quality", "tool_argument_schema", "tool_outcome", "tool_fault_tolerance", "artifact_semantics_quality", "domain_package_quality"],
+        failure_modes=["implementation_bug", "integration_gap", "schema_error", "latency_or_cost", "framework_lifecycle_gap", "framework_portability_gap", "trust_boundary_gap", "control_plane_gap", "fault_tolerance_failure", "artifact_semantics_failure", "domain_package_failure"],
+        patch_strategies=["fix code path", "add schema validation", "add timeouts"],
+    ),
+    "evaluator": AgentComponentSpec(
+        name="evaluator",
+        config_paths=["evaluation", "metrics", "rubric", "evaluation.trajectory_templates", "trajectory_templates", "evaluation.agent_memory_lineage", "evaluation.agent_memory_lineage_quality", "evaluation.agent_memory_lineage_quality.required_evidence", "evaluation.agent_memory_lineage_quality.required_signals", "evaluation.agent_memory_lineage_quality.required_operation_types", "evaluation.agent_memory_lineage_quality.required_policies", "evaluation.agent_memory_lineage_quality.max_open_poisoning", "evaluation.agent_memory_lineage_quality.max_unattributed_memories", "evaluation.agent_memory_lineage_quality.max_isolation_violations", "evaluation.agent_memory_lineage_quality.max_retention_violations", "evaluation.agent_memory_lineage_quality.max_policy_violations", "evaluation.persistent_state_attack", "evaluation.required_persistent_state_attack", "evaluation.persistent_state_attack_quality", "evaluation.persistent_state_attack_quality.required_channels", "evaluation.persistent_state_attack_quality.required_attack_types", "evaluation.persistent_state_attack_quality.max_write_success_rate", "evaluation.persistent_state_attack_quality.max_incorporation_rate", "evaluation.persistent_state_attack_quality.max_activation_rate", "evaluation.persistent_state_attack_quality.max_e2e_attack_success_rate", "evaluation.agent_integration", "evaluation.agent_integration_quality", "evaluation.framework_import", "evaluation.framework_import_quality", "evaluation.framework_import_quality.required_frameworks", "evaluation.framework_import_quality.required_export_types", "evaluation.framework_import_quality.required_signals", "evaluation.framework_import_quality.max_failed_sources", "evaluation.red_team_readiness", "evaluation.red_team_readiness_quality", "evaluation.red_team_readiness_quality.required_evidence", "evaluation.red_team_readiness_quality.required_signals", "evaluation.red_team_readiness_quality.required_ready_components", "evaluation.red_team_readiness_quality.max_blocking_gaps", "evaluation.observability_replay", "evaluation.observability_replay_quality", "evaluation.optimizer_trace", "evaluation.optimizer_trace_quality", "evaluation.optimizer_trace_quality.required_roles", "evaluation.optimizer_trace_quality.required_search_paths", "evaluation.optimizer_trace_quality.required_governance_signals", "evaluation.optimizer_trace_quality.min_governance_checks", "evaluation.manifest_optimization", "evaluation.required_manifest_optimization", "evaluation.manifest_optimization_quality", "evaluation.manifest_optimization_quality.required_search_paths", "evaluation.manifest_optimization_quality.required_metrics", "evaluation.framework_runtime", "evaluation.framework_runtime_contract", "evaluation.framework_lifecycle", "evaluation.framework_lifecycle_quality", "evaluation.framework_capability_quality", "evaluation.framework_probe_quality", "evaluation.framework_portability_quality", "evaluation.agent_trust_boundary_quality", "evaluation.agent_trust_boundary_quality.required_controls", "evaluation.agent_trust_boundary_quality.required_categories", "evaluation.agent_trust_boundary_quality.min_control_rate", "evaluation.agent_trust_boundary_quality.max_high_risk_unmitigated_threats", "evaluation.agent_control_plane_quality", "evaluation.agent_control_plane_quality.required_controls", "evaluation.agent_control_plane_quality.required_categories", "evaluation.agent_control_plane_quality.min_control_rate", "evaluation.agent_control_plane_quality.max_high_risk_uncontained_incidents", "evaluation.framework_transcript_quality", "evaluation.orchestration_trace_quality", "evaluation.streaming_trace_quality", "evaluation.world_contract_quality", "evaluation.adversarial_resilience", "evaluation.red_team_campaign", "evaluation.red_team_campaign_quality", "evaluation.red_team_campaign_quality.required_taxonomies", "evaluation.red_team_campaign_quality.required_attack_types", "evaluation.red_team_campaign_quality.required_surfaces", "evaluation.red_team_campaign_quality.required_channels", "evaluation.red_team_campaign_quality.required_providers", "evaluation.red_team_campaign_quality.required_frameworks", "evaluation.red_team_campaign_quality.max_open_high_findings", "evaluation.red_team_campaign_quality.max_failed_runs", "evaluation.cross_trial_memory_skill", "evaluation.voice_timing_distribution", "optimizer", "optimizer.trace", "optimizer.society_trace", "optimizer.roles", "optimizer.role_graph", "optimizer.proposals", "optimizer.credit", "optimizer.diagnostics", "optimizer.governance", "optimization", "optimization.target", "optimization.target.search_space", "optimization.optimizer", "optimization.optimizer.max_candidates", "manifest_optimization", "optimization.manifest_optimization", "framework.import_manifest", "framework.import.sources", "framework.runtime", "framework.lifecycle", "framework.capabilities", "framework.probes", "framework.portability", "framework.trust_boundary", "framework.control_plane", "framework.transcript", "orchestration.trace", "streaming.trace", "world.contract", "adversarial.attack_pack", "red_team.campaign", "red_team.readiness", "observability.replay", "observability.replay_pack", "evaluation.artifact_semantics", "evaluation.domain_packages"],
+        metrics=["judge_agreement", "eval_coverage", "agent_goal_accuracy", "tool_call_accuracy", "tool_call_f1", "policy_adherence", "memory_correctness", "agent_memory_lineage_coverage", "agent_memory_lineage_quality", "persistent_state_attack_coverage", "persistent_state_attack_quality", "multimodal_faithfulness", "artifact_grounding_quality", "artifact_semantics_quality", "domain_package_quality", "source_contradiction", "agent_integration_coverage", "agent_integration_quality", "workspace_run_coverage", "workspace_run_quality", "red_team_campaign_coverage", "red_team_campaign_quality", "red_team_readiness_coverage", "red_team_readiness_quality", "observability_replay_coverage", "observability_replay_quality", "optimizer_trace_coverage", "optimizer_trace_quality", "manifest_optimization_coverage", "manifest_optimization_quality", "framework_import_coverage", "framework_import_quality", "framework_runtime_coverage", "framework_runtime_contract", "framework_lifecycle_coverage", "framework_lifecycle_quality", "framework_capability_coverage", "framework_capability_quality", "framework_probe_coverage", "framework_probe_quality", "framework_portability_coverage", "framework_portability_quality", "agent_trust_boundary_coverage", "agent_trust_boundary_quality", "agent_control_plane_coverage", "agent_control_plane_quality", "framework_transcript_quality", "orchestration_trace_coverage", "orchestration_flow_quality", "streaming_trace_coverage", "streaming_interaction_quality", "world_contract_coverage", "world_contract_quality", "adversarial_resilience", "cross_trial_memory_skill", "voice_timing_distribution_quality"],
+        failure_modes=["evaluation_gap", "integration_gap", "framework_trace_gap", "framework_lifecycle_gap", "framework_capability_gap", "framework_probe_gap", "framework_portability_gap", "trust_boundary_gap", "control_plane_gap", "reliability_failure", "framework_transcript_gap", "orchestration_trace_gap", "orchestration_flow_failure", "streaming_trace_gap", "streaming_interaction_failure", "world_contract_gap", "world_contract_violation", "adversarial_resilience_failure", "cross_trial_memory_skill_failure", "artifact_semantics_failure", "domain_package_failure", "voice_timing_distribution_failure"],
+        patch_strategies=["add trajectory/step evals", "add deterministic state checks"],
+    ),
+    "multi_agent": AgentComponentSpec(
+        name="multi_agent",
+        config_paths=[
+            "multi_agent",
+            "multi_agent.trace",
+            "multi_agent.roles",
+            "multi_agent.contracts",
+            "multi_agent.handoffs",
+            "multi_agent.reviews",
+            "multi_agent.reconciliation",
+            "optimizer",
+            "optimizer.trace",
+            "optimizer.society",
+            "optimizer.society_trace",
+            "optimizer.strategy",
+            "optimizer.max_rounds",
+            "optimizer.roles",
+            "optimizer.role_graph",
+            "optimizer.proposals",
+            "optimizer.credit",
+            "optimizer.diagnostics",
+            "optimizer.governance",
+            "optimizer.governance.role_diversity",
+            "optimizer.governance.mediator",
+            "optimizer.governance.contract_gate",
+            "optimizer.governance.rollback",
+            "optimizer.governance.search_locality",
+            "optimizer.governance.dependency_audit",
+            "optimizer.backend_portfolio",
+            "optimizer.backends",
+            "optimizer.backend_selector",
+            "optimizer.backend_selector.policy",
+            "optimizer.backend_trials",
+            "optimizer.backend_evidence",
+            "optimizer.portfolio_gate",
+            "optimization",
+            "optimization.target",
+            "optimization.target.search_space",
+            "optimization.optimizer",
+            "optimization.optimizer.max_candidates",
+            "manifest_optimization",
+            "optimization.manifest_optimization",
+            "evaluation.optimizer_trace_quality",
+            "evaluation.optimizer_trace_quality.required_roles",
+            "evaluation.optimizer_trace_quality.required_search_paths",
+            "evaluation.optimizer_trace_quality.required_governance_signals",
+            "evaluation.optimizer_trace_quality.min_governance_checks",
+            "evaluation.optimizer_portfolio_quality",
+            "evaluation.manifest_optimization_quality",
+            "evaluation.manifest_optimization_quality.required_search_paths",
+            "evaluation.manifest_optimization_quality.required_metrics",
+            "orchestration.handoffs",
+            "orchestration.routes",
+            "workflow.handoffs",
+            "handoffs",
+            "roles",
+            "debate",
+        ],
+        metrics=[
+            "handoff_accuracy",
+            "coordination_success",
+            "multi_agent_trace_coverage",
+            "multi_agent_coordination_quality",
+            "optimizer_trace_coverage",
+            "optimizer_trace_quality",
+            "optimizer_portfolio_coverage",
+            "optimizer_portfolio_quality",
+            "manifest_optimization_coverage",
+            "manifest_optimization_quality",
+            "orchestration_flow_quality",
+        ],
+        failure_modes=["coordination_failure", "poor_plan", "orchestration_flow_failure"],
+        patch_strategies=["clarify roles", "add handoff contracts", "add reconciliation"],
+    ),
+    "model": AgentComponentSpec(
+        name="model",
+        config_paths=["model", "llm", "inference", "generation"],
+        metrics=["quality", "latency", "cost", "source_contradiction"],
+        failure_modes=["latency_or_cost", "hallucination", "context_overload"],
+        patch_strategies=["route to model tier", "adjust temperature/context"],
+    ),
+    "voice": AgentComponentSpec(
+        name="voice",
+        config_paths=[
+            "voice",
+            "voice.trace",
+            "voice.export",
+            "voice.export.auth",
+            "voice.export.pagination",
+            "voice.export.cursor",
+            "voice.export.page_size",
+            "voice.trace.livekit",
+            "voice.trace.vapi",
+            "voice.trace.pipecat",
+            "voice.trace.bland",
+            "voice.webrtc",
+            "voice.webrtc.stats",
+            "voice.webrtc.get_stats",
+            "voice.webrtc.rtp",
+            "voice.webrtc.packet_counters",
+            "voice.webrtc.track",
+            "voice.webrtc.codec",
+            "voice.webrtc.audio_level",
+            "voice.transport",
+            "voice.frames",
+            "voice.media",
+            "voice.audio_decode",
+            "voice.waveform",
+            "voice.diarization",
+            "voice.perceptual",
+            "voice.routing",
+            "voice.noise",
+            "voice.overlap",
+            "voice.snr",
+            "voice.clipping",
+            "voice.jitter",
+            "voice.packet_loss",
+            "voice.transport.packet_loss",
+            "voice.timing_distribution",
+            "voice.timing",
+            "voice.endpointing",
+            "voice.eou",
+            "voice.vad",
+            "voice.stt_latency",
+            "voice.tts_latency",
+            "voice.turn_latency",
+            "voice.jitter_buffer",
+            "vad",
+            "stt",
+            "tts",
+            "turn_taking",
+        ],
+        metrics=[
+            "turn_taking",
+            "interruption_handling",
+            "audio_quality",
+            "voice_trace_coverage",
+            "voice_interaction_quality",
+            "voice_timing_distribution_quality",
+        ],
+        failure_modes=["voice_turn_taking_failure", "voice_timing_distribution_failure", "latency_or_cost"],
+        patch_strategies=[
+            "tune VAD/endpointing",
+            "adjust TTS/STT model",
+            "add noise cancellation and frame replay checks",
+            "capture timing distributions and reduce p95 stage latency",
+        ],
+    ),
+    "browser": AgentComponentSpec(
+        name="browser",
+        config_paths=[
+            "browser",
+            "trajectory.browser",
+            "browser.trace",
+            "browser.trace.har",
+            "browser.actions",
+            "browser.resources",
+            "browser.resource_bodies",
+            "browser.actionability",
+            "browser.storage_state",
+            "browser.cookies",
+            "browser.local_storage",
+            "browser.session_storage",
+            "browser.runtime",
+            "browser.runtime_events",
+            "browser.performance_entries",
+            "browser.performance_timing",
+            "browser.selectors",
+            "browser.regions",
+            "browser.screenshot_diff",
+            "browser.screenshot_diff.pixel",
+            "browser.screenshot_diff.semantic",
+            "browser.screenshot_diff.mask",
+            "browser.semantic_regions",
+            "browser.masked_regions",
+            "browser.allowed_regions",
+            "browser.forbidden_regions",
+            "browser.pixel_diff",
+            "browser.trace.playwright",
+            "browser.trace.openai_cua",
+            "browser.trace.browser_use",
+            "browser.trace.video",
+            "browser.perturbations",
+            "browser.mutations",
+            "browser.mutation_pack",
+            "browser.selector_fallbacks",
+            "browser.refresh_before_action",
+            "browser.actionability_recheck",
+            "browser.storage_recheck",
+            "browser.runtime_recheck",
+            "browser.overlay_handling",
+            "browser.layout_shift",
+            "browser.layout_shift_distribution",
+            "browser.stale_screenshot",
+            "browser.refresh_snapshot",
+            "browser.injection_surfaces",
+            "dom",
+            "screenshot",
+            "video",
+            "playwright",
+        ],
+        metrics=["gui_grounding", "dom_state_success", "browser_trace_coverage", "browser_action_outcome", "browser_grounding_quality", "browser_mutation_resilience", "trajectory_browser_action_safety"],
+        failure_modes=["perception_grounding_failure", "unsafe_action", "environment_mismatch", "browser_action_failure", "browser_mutation_failure"],
+        patch_strategies=["capture DOM/screenshot/coordinate evidence", "constrain browser actions", "stabilize browser action selectors", "add mutation-pack refresh, storage/runtime recheck, and selector fallback handling"],
+    ),
+    "cua": AgentComponentSpec(
+        name="cua",
+        config_paths=[
+            "cua",
+            "cua.coordinates",
+            "cua.trace.openai",
+            "cua.actionability",
+            "computer_use",
+            "browser.policy",
+            "trajectory.browser",
+            "browser.trace",
+            "browser.trace.openai_cua",
+            "browser.trace.browser_use",
+            "browser.trace.har",
+            "browser.actions",
+            "browser.resource_bodies",
+            "browser.actionability",
+            "browser.storage_state",
+            "browser.runtime",
+            "browser.runtime_events",
+            "browser.performance_timing",
+            "browser.mutations",
+            "browser.mutation_pack",
+            "browser.selector_fallbacks",
+            "browser.actionability_recheck",
+            "browser.storage_recheck",
+            "browser.runtime_recheck",
+            "browser.regions",
+            "browser.screenshot_diff.semantic",
+            "browser.screenshot_diff.mask",
+            "browser.semantic_regions",
+            "browser.masked_regions",
+            "browser.layout_shift",
+            "browser.stale_screenshot",
+            "browser.refresh_snapshot",
+            "cua.semantic_regions",
+            "cua.screenshot_masks",
+            "cua.runtime_events",
+        ],
+        metrics=["action_success", "gui_grounding", "state_goal_accuracy", "browser_trace_coverage", "browser_action_outcome", "browser_grounding_quality", "browser_mutation_resilience", "trajectory_browser_action_safety"],
+        failure_modes=["perception_grounding_failure", "unsafe_action", "environment_mismatch", "browser_action_failure", "browser_mutation_failure"],
+        patch_strategies=["sandbox actions", "add screenshot/action replay", "handle mutation-pack fallbacks before CUA actions"],
+    ),
+    "custom": AgentComponentSpec(name="custom"),
+}
+
+
+FAILURE_ROUTES: Dict[FailureMode, List[AgentComponent]] = {
+    "unclear_goal": ["objective", "planner", "prompt", "evaluator"],
+    "poor_plan": ["planner", "prompt", "multi_agent"],
+    "wrong_tool": ["tools", "router", "prompt"],
+    "bad_tool_arguments": ["tools", "implementation"],
+    "tool_execution_error": ["tools", "action", "environment", "implementation"],
+    "missing_tool": ["tools", "environment"],
+    "memory_write_failure": ["memory", "implementation"],
+    "memory_retrieval_failure": ["memory", "retrieval", "router"],
+    "memory_contamination": ["memory", "policy", "security"],
+    "retrieval_relevance_failure": ["retrieval", "memory"],
+    "policy_violation": ["policy", "security", "prompt", "tools"],
+    "unsafe_action": ["policy", "security", "action", "browser", "cua"],
+    "hallucination": ["retrieval", "prompt", "model", "memory"],
+    "schema_error": ["implementation", "tools", "action"],
+    "environment_mismatch": ["harness", "environment", "world", "browser", "cua"],
+    "latency_or_cost": ["model", "router", "tools", "voice", "streaming", "implementation"],
+    "coordination_failure": ["multi_agent", "planner", "memory", "harness", "evaluator"],
+    "evaluation_gap": ["evaluator", "harness", "objective"],
+    "integration_gap": ["integration", "framework", "voice", "streaming", "environment", "harness", "evaluator", "implementation"],
+    "implementation_bug": ["implementation", "environment", "harness"],
+    "perception_grounding_failure": ["perception", "voice", "browser", "cua"],
+    "artifact_semantics_failure": ["perception", "environment", "implementation", "evaluator"],
+    "domain_package_failure": ["environment", "implementation", "evaluator", "tools", "policy"],
+    "context_overload": ["memory", "router", "model", "planner"],
+    "voice_turn_taking_failure": ["voice", "perception"],
+    "voice_timing_distribution_failure": ["voice", "perception", "streaming", "harness", "evaluator"],
+    "browser_action_failure": ["browser", "cua", "action", "environment", "harness"],
+    "browser_mutation_failure": ["browser", "cua", "action", "environment", "harness", "evaluator"],
+    "autonomy_loop_failure": ["autonomy", "planner", "memory", "policy", "tools", "harness"],
+    "cross_trial_memory_skill_failure": ["autonomy", "memory", "framework", "harness", "evaluator"],
+    "framework_trace_gap": ["framework", "harness", "implementation", "evaluator", "model", "tools", "router"],
+    "framework_lifecycle_gap": ["framework", "harness", "implementation", "evaluator", "streaming", "tools", "memory"],
+    "framework_capability_gap": ["framework", "harness", "implementation", "evaluator", "tools", "memory", "streaming", "orchestration", "security", "environment"],
+    "framework_probe_gap": ["framework", "harness", "implementation", "evaluator", "tools", "memory", "streaming", "orchestration", "security", "environment"],
+    "framework_portability_gap": ["framework", "harness", "implementation", "evaluator", "tools", "memory", "streaming", "orchestration", "security", "environment"],
+    "trust_boundary_gap": ["security", "policy", "tools", "memory", "framework", "environment", "harness", "implementation", "evaluator"],
+    "control_plane_gap": ["autonomy", "policy", "security", "tools", "memory", "framework", "environment", "harness", "implementation", "evaluator"],
+    "framework_transcript_gap": ["framework", "harness", "planner", "tools", "memory", "router", "implementation", "evaluator"],
+    "orchestration_trace_gap": ["orchestration", "framework", "harness", "implementation", "evaluator"],
+    "orchestration_flow_failure": ["orchestration", "planner", "router", "multi_agent", "tools", "memory", "implementation", "harness"],
+    "streaming_trace_gap": ["streaming", "framework", "harness", "implementation", "evaluator"],
+    "streaming_interaction_failure": ["streaming", "framework", "model", "router", "voice", "implementation", "harness"],
+    "world_contract_gap": ["world", "environment", "harness", "tools", "policy", "implementation", "evaluator"],
+    "world_contract_violation": ["world", "environment", "policy", "tools", "action", "planner", "implementation", "harness"],
+    "adversarial_resilience_failure": ["security", "policy", "tools", "memory", "browser", "environment", "harness", "evaluator", "implementation"],
+    "reliability_failure": ["autonomy", "planner", "policy", "tools", "memory", "framework", "environment", "harness", "evaluator"],
+    "fault_tolerance_failure": ["policy", "tools", "action", "environment", "implementation", "harness"],
+    "unknown": ["custom"],
+}
+
+
+KEYWORD_FAILURES: Dict[FailureMode, List[str]] = {
+    "wrong_tool": [
+        "wrong tool",
+        "tool selection",
+        "unexpected tool",
+        "extra tool",
+        "tool call accuracy",
+        "tool call f1",
+        "trajectory tool",
+        "tool order",
+    ],
+    "bad_tool_arguments": ["bad argument", "slot", "parameter", "invalid argument", "tool argument schema", "tool schema", "mcp tool schema"],
+    "tool_execution_error": ["tool error", "api error", "exception", "timeout", "tool outcome", "tool result", "mcp tool result", "mcp tool error"],
+    "missing_tool": ["missing tool", "no tool", "unsupported action", "tools/list", "mcp tools/list"],
+    "memory_write_failure": [
+        "forgot",
+        "not stored",
+        "memory write",
+        "memory correctness",
+        "trajectory memory",
+        "checkpoint state",
+        "state persistence",
+    ],
+    "memory_retrieval_failure": [
+        "memory retrieval",
+        "could not recall",
+        "lost context",
+        "missing memory",
+        "memory attribution",
+        "missing checkpoint",
+        "missing session",
+    ],
+    "memory_contamination": [
+        "poisoned memory",
+        "irrelevant memory",
+        "stale memory",
+        "agent memory lineage",
+        "memory lineage",
+        "memory provenance",
+        "memory poisoning",
+        "source attribution",
+        "tenant isolation",
+        "unattributed memory",
+        "retention policy",
+        "deletion policy",
+    ],
+    "retrieval_relevance_failure": [
+        "irrelevant context",
+        "bad retrieval",
+        "missing context",
+        "missing citation",
+        "missing source",
+        "retrieval context",
+        "stale retrieval",
+        "retrieval ranking",
+        "attribution",
+        "retrieval memory",
+    ],
+    "policy_violation": [
+        "policy violation",
+        "violated policy",
+        "unsafe response",
+        "policy adherence",
+        "trajectory policy",
+        "environment injection",
+        "retrieved instruction",
+        "tool output injection",
+    ],
+    "unsafe_action": ["unsafe action", "unauthorized", "irreversible"],
+    "hallucination": [
+        "hallucination",
+        "unsupported",
+        "not grounded",
+        "fabricated",
+        "source contradiction",
+        "source contradicted",
+        "contradicted claim",
+        "conflicting source",
+    ],
+    "schema_error": ["schema", "json", "parse", "validation"],
+    "environment_mismatch": ["environment", "fixture", "state mismatch", "broken url"],
+    "latency_or_cost": ["latency", "cost", "too slow", "token"],
+    "coordination_failure": [
+        "handoff",
+        "coordination",
+        "role confusion",
+        "wrong specialist",
+        "multi-agent trace",
+        "optimizer trace",
+        "optimizer_trace_coverage",
+        "optimizer_trace_quality",
+        "optimizer society trace",
+        "manifest optimization",
+        "manifest_optimization_coverage",
+        "manifest_optimization_quality",
+        "manifest optimization artifact",
+        "manifest optimization quality",
+        "manifest optimization coverage",
+        "optimizer backend portfolio",
+        "backend portfolio",
+        "optimizer portfolio",
+        "optimizer_portfolio_coverage",
+        "optimizer_portfolio_quality",
+        "backend selector",
+        "backend selection",
+        "backend evidence",
+        "backend trial",
+        "portfolio gate",
+        "missing optimizer backend",
+        "optimizer role",
+        "role graph",
+        "proposal credit",
+        "role credit",
+        "credit assignment",
+        "optimizer governance",
+        "governance check",
+        "role diversity",
+        "mediator review",
+        "contract gate",
+        "rollback check",
+        "search locality",
+        "dependency audit",
+        "society search",
+        "council search",
+        "handoff contract",
+        "coordination quality",
+        "review missing",
+        "reconciliation",
+    ],
+    "evaluation_gap": ["eval gap", "judge wrong", "metric missing", "observability replay metric"],
+    "integration_gap": [
+        "agent integration",
+        "agent integration coverage",
+        "agent integration quality",
+        "workspace run",
+        "workspace run coverage",
+        "workspace run quality",
+        "autonomous code run",
+        "github checkout",
+        "red team readiness",
+        "red-team readiness",
+        "red_team_readiness",
+        "red team preflight",
+        "readiness preflight",
+        "preflight gate",
+        "framework import not ready",
+        "campaign not ready",
+        "workspace run not ready",
+        "red team coverage",
+        "red team quality",
+        "red-team quality",
+        "red-team finding",
+        "framework import manifest",
+        "framework import coverage",
+        "framework import quality",
+        "framework import source",
+        "agent memory lineage coverage",
+        "agent_memory_lineage_coverage",
+        "memory lineage coverage",
+        "secret redaction",
+        "provider integration",
+        "channel integration",
+        "agent definition missing",
+        "persona missing",
+        "livekit integration",
+        "livekit sip",
+        "livekit webrtc",
+        "vapi integration",
+        "vapi phone",
+        "vapi webrtc",
+        "retell integration",
+        "bland integration",
+        "bland phone",
+        "bland sip",
+        "elevenlabs integration",
+        "deepgram integration",
+        "agora integration",
+        "pipecat integration",
+        "twilio integration",
+        "phone integration",
+        "sip integration",
+        "traceai framework",
+        "future agi observability",
+        "futureagi observability",
+    ],
+    "implementation_bug": ["bug", "traceback", "dependency", "runtime"],
+    "perception_grounding_failure": [
+        "artifact",
+        "artifact grounding",
+        "artifact grounding quality",
+        "artifact support missing",
+        "artifact claim missing",
+        "artifact contradicted claim",
+        "artifact supported claim",
+        "audio",
+        "image",
+        "screenshot",
+        "dom",
+        "ocr",
+        "vision",
+        "grounding",
+        "multimodal faithfulness",
+        "multimodal claim",
+        "browser grounding",
+        "browser trace",
+        "action replay",
+        "coordinate region",
+        "screenshot diff",
+        "pixel diff",
+        "pixel screenshot diff",
+        "screenshot pixel diff",
+        "real screenshot diff",
+        "semantic screenshot diff",
+        "semantic visual diff",
+        "masked screenshot diff",
+        "masked visual diff",
+        "masked region",
+        "forbidden region changed",
+        "allowed semantic region",
+        "playwright trace",
+        "trace.zip",
+        "browser video",
+        "layout shift",
+        "stale screenshot",
+        "stale snapshot",
+        "perturbation",
+        "prompt-injection surface",
+        "console log",
+        "network log",
+        "storage state",
+        "local storage",
+        "session storage",
+        "browser cookie",
+        "runtime event",
+        "runtime error",
+        "page error",
+        "web error",
+        "performance entry",
+        "performance timing",
+    ],
+    "artifact_semantics_failure": [
+        "artifact semantics",
+        "artifact semantics quality",
+        "structured artifact",
+        "artifact field mismatch",
+        "artifact answer field missing",
+        "artifact row missing",
+        "artifact row field mismatch",
+        "artifact event sequence mismatch",
+        "artifact semantic forbidden answer",
+    ],
+    "domain_package_failure": [
+        "domain package",
+        "domain package quality",
+        "support ticket package",
+        "ledger package",
+        "calendar package",
+        "email thread package",
+        "domain package field mismatch",
+        "domain package required field missing",
+        "domain package status invalid",
+        "domain package ledger unbalanced",
+        "domain package calendar overlap",
+        "domain package chronology invalid",
+        "domain package participant missing",
+    ],
+    "context_overload": ["context overflow", "too many tools", "context window"],
+    "voice_turn_taking_failure": [
+        "barge",
+        "interrupt",
+        "vad",
+        "stt",
+        "tts",
+        "voice trace",
+        "voice interaction",
+        "voice frame",
+        "voice export",
+        "voice export auth",
+        "voice export pagination",
+        "authenticated voice export",
+        "paginated voice export",
+        "livekit export",
+        "pipecat export",
+        "webrtc",
+        "getstats",
+        "get stats",
+        "rtc stats",
+        "rtp",
+        "inbound rtp",
+        "remote inbound rtp",
+        "track identifier",
+        "track stats",
+        "codec stats",
+        "audio level",
+        "waveform",
+        "decoded audio",
+        "media decode",
+        "wav",
+        "pcm",
+        "sample rate",
+        "duration",
+        "rms",
+        "peak",
+        "recording",
+        "diarization",
+        "speaker segment",
+        "speaker missing",
+        "snr",
+        "mos",
+        "perceptual",
+        "clipping",
+        "jitter",
+        "packet loss",
+        "overlapping speech",
+        "noise",
+        "call route",
+        "call routing",
+    ],
+    "voice_timing_distribution_failure": [
+        "voice timing",
+        "timing distribution",
+        "timing stage",
+        "voice latency p95",
+        "turn latency",
+        "endpointing",
+        "end of utterance",
+        "eou",
+        "vad latency",
+        "stt latency",
+        "llm latency",
+        "tts latency",
+        "time to first audio",
+        "ttft",
+        "jitter buffer",
+        "voice timing sample",
+    ],
+    "browser_action_failure": [
+        "browser action outcome",
+        "browser state mismatch",
+        "trajectory browser action safety",
+        "browser action failed",
+        "browser grounding quality",
+        "coordinate mismatch",
+        "region mismatch",
+        "screenshot diff missing",
+        "pixel diff",
+        "pixel screenshot diff",
+        "screenshot pixel diff",
+        "real screenshot diff",
+        "semantic screenshot diff",
+        "semantic visual diff",
+        "masked screenshot diff",
+        "masked visual diff",
+        "masked region",
+        "forbidden region changed",
+        "allowed semantic region",
+        "layout shift",
+        "layout shift distribution",
+        "cls distribution",
+        "stale screenshot",
+        "stale snapshot",
+        "refresh snapshot",
+        "playwright trace",
+        "openai cua",
+        "openai computer use",
+        "computer use trace",
+        "computer call",
+        "browser use trace",
+        "browser-use trace",
+        "har",
+        "http archive",
+        "resource body",
+        "resource bodies",
+        "actionability",
+        "actionability timeline",
+        "browser video",
+        "perturbation",
+        "prompt injection surface",
+        "storage state",
+        "local storage",
+        "session storage",
+        "browser cookie",
+        "runtime event",
+        "runtime error",
+        "page error",
+        "web error",
+        "performance threshold",
+        "performance timing",
+        "dom missing",
+        "selector mismatch",
+        "locator mismatch",
+        "click failed",
+        "cua action failed",
+    ],
+    "browser_mutation_failure": [
+        "browser mutation",
+        "browser mutation pack",
+        "browser mutation resilience",
+        "browser_mutation_resilience",
+        "mutation pack",
+        "stale selector",
+        "selector alias",
+        "selector fallback",
+        "fallback selector",
+        "storage drift",
+        "runtime mutation",
+        "network mutation",
+        "network latency",
+        "overlay handling",
+        "actionability recheck",
+        "storage recheck",
+        "runtime recheck",
+        "browser mutations tool",
+    ],
+    "autonomy_loop_failure": [
+        "autonomy loop",
+        "control loop",
+        "observe orient plan act",
+        "reflection missing",
+        "missing reflection",
+        "self check",
+        "verifier missing",
+        "verifier quality",
+        "plan validity",
+        "reflection usefulness",
+        "stop decision",
+        "skill library",
+        "monitor control",
+    ],
+    "framework_trace_gap": [
+        "framework trace",
+        "framework import manifest",
+        "framework import coverage",
+        "framework import quality",
+        "framework import source",
+        "trace export missing",
+        "event stream missing",
+        "capability matrix missing",
+        "probe suite missing",
+        "portability matrix missing",
+        "framework span",
+        "framework adapter conformance",
+        "framework adapter signal",
+        "framework adapter mapping",
+        "framework runtime",
+        "runtime contract",
+        "adapter runtime",
+        "input mode",
+        "runtime input",
+        "runtime method",
+        "runtime metadata",
+        "missing span",
+        "trace export",
+        "export auth",
+        "authenticated export",
+        "authorization header",
+        "api key header",
+        "paginated export",
+        "export pagination",
+        "next cursor",
+        "next page",
+        "page token",
+        "traceai export",
+        "futureagi trace",
+        "future agi trace",
+        "resource spans",
+        "resourcespans",
+        "scope spans",
+        "scopespans",
+        "span attributes",
+        "otel",
+        "otlp",
+        "opentelemetry",
+        "instrumentation",
+        "tracing disabled",
+        "autogen",
+        "llamaindex",
+        "llama index",
+        "dspy",
+        "mcp",
+        "mcp tool session",
+        "mcp tool schema",
+        "mcp tool call",
+        "mcp tool result",
+        "mcp tool error",
+        "tools/list",
+        "tools/call",
+        "langgraph event",
+        "openai agents trace",
+        "pipecat frame",
+    ],
+    "framework_lifecycle_gap": [
+        "framework lifecycle",
+        "framework lifecycle trace",
+        "framework lifecycle coverage",
+        "framework lifecycle quality",
+        "lifecycle phase",
+        "missing lifecycle",
+        "missing setup",
+        "missing initialization",
+        "missing tool registration",
+        "tool registration missing",
+        "missing lifecycle session",
+        "missing session lifecycle",
+        "session cleanup",
+        "cleanup missing",
+        "teardown missing",
+        "checkpoint missing",
+        "resume missing",
+        "cancel resume",
+        "cancellation missing",
+        "retry missing",
+        "lifecycle retry",
+        "state persistence missing",
+        "lifecycle terminal status",
+    ],
+    "framework_capability_gap": [
+        "framework capability",
+        "framework capability matrix",
+        "framework capability coverage",
+        "framework capability quality",
+        "capability matrix",
+        "missing framework capability",
+        "unsupported capability",
+        "missing capability evidence",
+        "missing framework task surface",
+        "task surface missing",
+        "missing tool capability",
+        "missing memory capability",
+        "missing streaming capability",
+        "missing lifecycle capability",
+        "missing orchestration capability",
+        "missing security capability",
+        "missing observability capability",
+        "missing export capability",
+        "supported capabilities low",
+        "support rate low",
+    ],
+    "framework_probe_gap": [
+        "framework probe",
+        "framework probe suite",
+        "framework probe coverage",
+        "framework probe quality",
+        "adapter probe",
+        "smoke probe",
+        "smoke test",
+        "required probe missing",
+        "probe operation missing",
+        "probe failed",
+        "probe blocked",
+        "required pass rate low",
+        "missing probe evidence",
+        "invoke probe",
+        "tool probe",
+        "memory probe",
+        "streaming probe",
+        "checkpoint probe",
+        "handoff probe",
+        "guardrail probe",
+        "trace export probe",
+        "export probe",
+    ],
+    "framework_transcript_gap": [
+        "framework transcript",
+        "framework transcript quality",
+        "langchain event stream",
+        "langchain stream_events",
+        "langgraph event stream",
+        "langgraph stream_events",
+        "missing framework event method",
+        "missing framework node",
+        "missing framework subgraph",
+        "framework tool sequence",
+        "framework state mismatch",
+        "framework checkpoint",
+        "missing framework checkpoint",
+        "framework checkpoint state",
+        "checkpoint state mismatch",
+        "checkpoint parent",
+        "checkpoint lineage",
+        "missing framework session",
+        "thread id",
+        "state persistence",
+        "framework output missing",
+        "framework error observed",
+        "missing framework speaker",
+        "framework speaker sequence",
+        "framework handoff",
+        "framework termination",
+        "framework tool owner",
+        "framework message missing",
+        "framework turn count",
+        "autogen groupchat",
+        "crewai event",
+        "openai agents handoff",
+        "multi-agent transcript",
+        "protocol event",
+        "stream projection",
+    ],
+    "orchestration_trace_gap": [
+        "orchestration trace",
+        "orchestration trace coverage",
+        "missing orchestration trace",
+        "workflow graph trace",
+        "workflow trace",
+        "graph trace",
+        "missing workflow node",
+        "missing workflow edge",
+        "missing orchestration node",
+        "missing orchestration route",
+        "orchestration step missing",
+        "orchestration event missing",
+    ],
+    "orchestration_flow_failure": [
+        "orchestration flow",
+        "orchestration flow quality",
+        "workflow route missing",
+        "orchestration route missing",
+        "orchestration node missing",
+        "forbidden orchestration node",
+        "orchestration retry missing",
+        "orchestration recovery missing",
+        "workflow recovery missing",
+        "orchestration latency threshold",
+        "orchestration cost threshold",
+        "orchestration terminal status",
+        "orchestration state mismatch",
+        "workflow budget",
+        "graph routing",
+        "retry policy",
+        "recovery policy",
+    ],
+    "streaming_trace_gap": [
+        "streaming trace",
+        "streaming trace coverage",
+        "missing streaming trace",
+        "missing stream event",
+        "missing stream chunk",
+        "missing chunk",
+        "missing tool delta",
+        "tool delta",
+        "tool-call delta",
+        "tool call delta",
+        "stream_events",
+        "event stream",
+        "langchain streaming",
+        "langgraph streaming",
+        "openai agents streaming",
+        "livekit session event",
+        "pipecat frame",
+        "time to first chunk",
+        "stream usage",
+    ],
+    "streaming_interaction_failure": [
+        "streaming interaction",
+        "streaming interaction quality",
+        "stream assembly",
+        "assembled text",
+        "final output missing",
+        "streaming output missing",
+        "chunk sequence",
+        "chunk count low",
+        "tool delta missing",
+        "first token latency",
+        "inter chunk gap",
+        "streaming gap",
+        "dropped stream",
+        "dropped event",
+        "backpressure",
+        "buffering",
+        "streaming completion",
+        "streaming finalization",
+        "unrecovered interruption",
+        "interruption recovery",
+    ],
+    "world_contract_gap": [
+        "world contract",
+        "world contract coverage",
+        "missing world contract",
+        "missing world actor",
+        "missing world resource",
+        "missing world transition",
+        "missing invariant",
+        "missing success condition",
+        "missing policy gate",
+        "missing adversarial surface",
+        "state machine",
+        "world state",
+        "interactive environment",
+        "stateful tool",
+        "required transition",
+    ],
+    "world_contract_violation": [
+        "world contract quality",
+        "world invariant violation",
+        "invariant violation",
+        "world transition missing",
+        "world transition count",
+        "world required transition",
+        "forbidden transition",
+        "world forbidden transition",
+        "world violation",
+        "world terminal status",
+        "world state mismatch",
+        "success condition missing",
+        "policy gate violation",
+        "precondition failed",
+        "postcondition failed",
+    ],
+    "adversarial_resilience_failure": [
+        "adversarial resilience",
+        "adversarial attack",
+        "attack pack",
+        "red team campaign",
+        "red-team campaign",
+        "red_team_campaign",
+        "red_team_campaign_coverage",
+        "red_team_campaign_quality",
+        "red_team_readiness_quality",
+        "attack surface matrix",
+        "attack surface cell",
+        "matrix cell",
+        "coverage matrix",
+        "run artifact missing",
+        "mitigation mapping missing",
+        "matrix evidence",
+        "readiness gate failed",
+        "red-team readiness gate",
+        "red team readiness gate",
+        "blocking readiness gap",
+        "trust boundary not ready",
+        "control plane not ready",
+        "red team taxonomy",
+        "red-team taxonomy",
+        "owasp agentic",
+        "owasp llm top 10",
+        "mcp security",
+        "garak",
+        "pyrit",
+        "inspect",
+        "multi-turn red team",
+        "open high finding",
+        "failed red team run",
+        "canary leak",
+        "forbidden term leak",
+        "blocked tool",
+        "blocked tool call",
+        "tool misuse",
+        "goal hijack",
+        "instruction manipulation",
+        "untrusted context",
+        "memory poisoning",
+        "context poisoning",
+        "environment injection",
+        "indirect prompt injection",
+        "safe response missing",
+    ],
+    "cross_trial_memory_skill_failure": [
+        "cross-trial memory",
+        "cross trial memory",
+        "cross_trial_memory_skill",
+        "memory precision",
+        "memory recall",
+        "memory persistence",
+        "recall after write",
+        "skill regression",
+        "skill persistence",
+        "skill library",
+    ],
+    "reliability_failure": [
+        "trial reliability",
+        "pass rate",
+        "pass@k",
+        "pass^k",
+        "inconsistent",
+        "flaky",
+        "observability replay",
+        "replay pack",
+        "regression replay",
+        "failed replay case",
+    ],
+    "fault_tolerance_failure": [
+        "fault tolerance",
+        "tool fault",
+        "transient failure",
+        "retry failed",
+        "rate limit",
+        "timeout recovery",
+    ],
+    "framework_portability_gap": [
+        "framework portability",
+        "framework portability matrix",
+        "framework portability coverage",
+        "framework portability quality",
+        "portability matrix",
+        "migration matrix",
+        "migration gap",
+        "adapter migration",
+        "source framework",
+        "target framework",
+        "source target mapping",
+        "required mapping missing",
+        "mapping missing",
+        "mapping blocked",
+        "mapping rate low",
+        "required mapping rate low",
+        "missing tool mapping",
+        "missing memory mapping",
+        "missing streaming mapping",
+        "missing lifecycle mapping",
+        "missing orchestration mapping",
+        "missing security mapping",
+        "missing observability mapping",
+        "missing export mapping",
+        "missing runtime mapping",
+        "portability evidence missing",
+    ],
+    "trust_boundary_gap": [
+        "agent trust boundary",
+        "trust boundary",
+        "trust-boundary",
+        "threat model",
+        "threat-model",
+        "agent trust-boundary model",
+        "agent_trust_boundary_coverage",
+        "agent_trust_boundary_quality",
+        "missing agent trust boundary",
+        "missing trust boundary",
+        "required control missing",
+        "missing required control",
+        "control rate low",
+        "required control rate low",
+        "permission missing",
+        "permissions missing",
+        "sandbox missing",
+        "audit missing",
+        "missing audit",
+        "missing canary",
+        "canary count low",
+        "human approval missing",
+        "approval gate missing",
+        "memory isolation missing",
+        "network egress",
+        "network egress missing",
+        "tool allowlist",
+        "tool allowlist missing",
+        "data boundary",
+        "data boundary missing",
+        "secret handling",
+        "secret handling missing",
+        "secret exfiltration",
+        "unmitigated threat",
+        "high risk unmitigated",
+    ],
+    "control_plane_gap": [
+        "agent control plane",
+        "control plane",
+        "runtime governance",
+        "agency control",
+        "agent_control_plane_coverage",
+        "agent_control_plane_quality",
+        "missing agent control plane",
+        "control-plane gap",
+        "action gate",
+        "action gates",
+        "policy gate",
+        "risk budget",
+        "budget exceeded",
+        "kill switch",
+        "circuit breaker",
+        "rollback missing",
+        "reversibility",
+        "uncontained incident",
+        "high risk uncontained",
+        "agency risk",
+        "human override",
+        "rate limit",
+        "drift detection",
+        "containment missing",
+    ],
+    "poor_plan": ["bad plan", "wrong step", "trajectory", "step order", "trajectory template"],
+    "unclear_goal": ["unclear goal", "ambiguous", "rubric", "agent goal accuracy", "goal mismatch"],
+}
+
+
+METRIC_FAILURES: Dict[str, FailureMode] = {
+    "task_completion": "unclear_goal",
+    "agent_goal_accuracy": "unclear_goal",
+    "goal_progress": "poor_plan",
+    "trajectory_score": "poor_plan",
+    "step_efficiency": "poor_plan",
+    "tool_selection_accuracy": "wrong_tool",
+    "tool_call_accuracy": "wrong_tool",
+    "tool_call_f1": "wrong_tool",
+    "function_name_match": "wrong_tool",
+    "parameter_validation": "bad_tool_arguments",
+    "function_call_accuracy": "bad_tool_arguments",
+    "tool_argument_schema": "bad_tool_arguments",
+    "tool_outcome": "tool_execution_error",
+    "action_safety": "unsafe_action",
+    "policy_adherence": "policy_violation",
+    "prompt_injection_resistance": "policy_violation",
+    "environment_injection_resistance": "policy_violation",
+    "adversarial_resilience": "adversarial_resilience_failure",
+    "secret_leakage": "policy_violation",
+    "memory_integrity": "memory_contamination",
+    "memory_correctness": "memory_write_failure",
+    "browser_action_safety": "unsafe_action",
+    "trajectory_browser_action_safety": "unsafe_action",
+    "browser_action_outcome": "browser_action_failure",
+    "browser_grounding_quality": "perception_grounding_failure",
+    "browser_mutation_resilience": "browser_mutation_failure",
+    "voice_turn_taking": "voice_turn_taking_failure",
+    "voice_trace_coverage": "voice_turn_taking_failure",
+    "voice_interaction_quality": "voice_turn_taking_failure",
+    "voice_timing_distribution_quality": "voice_timing_distribution_failure",
+    "autonomy_loop_coverage": "autonomy_loop_failure",
+    "autonomy_loop_quality": "autonomy_loop_failure",
+    "cross_trial_memory_skill": "cross_trial_memory_skill_failure",
+    "framework_import_coverage": "framework_trace_gap",
+    "framework_import_quality": "framework_trace_gap",
+    "framework_trace_coverage": "framework_trace_gap",
+    "framework_adapter_conformance": "framework_trace_gap",
+    "framework_runtime_coverage": "framework_trace_gap",
+    "framework_runtime_contract": "framework_trace_gap",
+    "framework_lifecycle_coverage": "framework_lifecycle_gap",
+    "framework_lifecycle_quality": "framework_lifecycle_gap",
+    "framework_capability_coverage": "framework_capability_gap",
+    "framework_capability_quality": "framework_capability_gap",
+    "framework_probe_coverage": "framework_probe_gap",
+    "framework_probe_quality": "framework_probe_gap",
+    "framework_portability_coverage": "framework_portability_gap",
+    "framework_portability_quality": "framework_portability_gap",
+    "agent_trust_boundary_coverage": "trust_boundary_gap",
+    "agent_trust_boundary_quality": "trust_boundary_gap",
+    "agent_control_plane_coverage": "control_plane_gap",
+    "agent_control_plane_quality": "control_plane_gap",
+    "framework_transcript_quality": "framework_transcript_gap",
+    "orchestration_trace_coverage": "orchestration_trace_gap",
+    "orchestration_flow_quality": "orchestration_flow_failure",
+    "streaming_trace_coverage": "streaming_trace_gap",
+    "streaming_interaction_quality": "streaming_interaction_failure",
+    "world_contract_coverage": "world_contract_gap",
+    "world_contract_quality": "world_contract_violation",
+    "retrieval_memory_attribution": "retrieval_relevance_failure",
+    "agent_memory_lineage_coverage": "integration_gap",
+    "agent_memory_lineage_quality": "memory_contamination",
+    "retrieval_context_quality": "retrieval_relevance_failure",
+    "source_grounding": "hallucination",
+    "source_contradiction": "hallucination",
+    "artifact_coverage": "perception_grounding_failure",
+    "artifact_grounding_quality": "perception_grounding_failure",
+    "artifact_semantics_quality": "artifact_semantics_failure",
+    "domain_package_quality": "domain_package_failure",
+    "multimodal_faithfulness": "perception_grounding_failure",
+    "browser_trace_coverage": "perception_grounding_failure",
+    "state_goal_accuracy": "environment_mismatch",
+    "multi_agent_trace_coverage": "coordination_failure",
+    "multi_agent_coordination_quality": "coordination_failure",
+    "optimizer_trace_coverage": "coordination_failure",
+    "optimizer_trace_quality": "coordination_failure",
+    "optimizer_portfolio_coverage": "coordination_failure",
+    "optimizer_portfolio_quality": "coordination_failure",
+    "manifest_optimization_coverage": "coordination_failure",
+    "manifest_optimization_quality": "coordination_failure",
+    "trial_reliability": "reliability_failure",
+    "tool_fault_tolerance": "fault_tolerance_failure",
+    "observability_replay_coverage": "evaluation_gap",
+    "observability_replay_quality": "reliability_failure",
+    "agent_integration_coverage": "integration_gap",
+    "agent_integration_quality": "integration_gap",
+    "workspace_run_coverage": "integration_gap",
+    "workspace_run_quality": "integration_gap",
+    "red_team_campaign_coverage": "integration_gap",
+    "red_team_campaign_quality": "adversarial_resilience_failure",
+    "red_team_readiness_coverage": "integration_gap",
+    "red_team_readiness_quality": "adversarial_resilience_failure",
+    "persistent_state_attack_coverage": "integration_gap",
+    "persistent_state_attack_quality": "adversarial_resilience_failure",
+}
+
+
+PERSISTENT_STATE_ATTACK_REPAIR_PATHS = [
+    "persistent_state_attack",
+    "persistent_state_attack.lifecycle",
+    "persistent_state_attack.write_policy",
+    "persistent_state_attack.context_rehydration",
+    "persistent_state_attack.activation_guard",
+    "persistent_state_attack.provenance",
+    "memory.write_policy",
+    "memory.write_quarantine",
+    "memory.provenance",
+    "memory.trust_labels",
+    "memory.rehydration_policy",
+    "policy.persistent_state_attack",
+    "policy.persistent_state_write_gate",
+    "policy.context_rehydration",
+    "policy.activation_guard",
+    "security.persistent_state_attack",
+    "security.stored_prompt_injection",
+    "environment.persistent_state_attack",
+    "environment.stored_prompt_injection",
+    "evaluation.required_persistent_state_attack",
+    "evaluation.persistent_state_attack_quality",
+    "evaluation.persistent_state_attack_quality.max_write_success_rate",
+    "evaluation.persistent_state_attack_quality.max_incorporation_rate",
+    "evaluation.persistent_state_attack_quality.max_activation_rate",
+    "evaluation.persistent_state_attack_quality.max_e2e_attack_success_rate",
+]
+
+
+PERSISTENT_STATE_ATTACK_FINDINGS = [
+    "missing_persistent_state_attack_key",
+    "persistent_state_case_count_low",
+    "persistent_state_channel_count_low",
+    "persistent_state_write_count_low",
+    "persistent_state_incorporation_count_low",
+    "persistent_state_activation_count_low",
+    "persistent_state_mitigation_count_low",
+    "persistent_state_artifact_count_low",
+    "persistent_state_written_count_high",
+    "persistent_state_incorporated_count_high",
+    "persistent_state_activated_count_high",
+    "persistent_state_wsr_high",
+    "persistent_state_ir_high",
+    "persistent_state_ar_high",
+    "persistent_state_e2e_asr_high",
+    "persistent_state_session_reset_missing",
+    "persistent_state_stage_metrics_missing",
+    "persistent_state_provenance_missing",
+    "persistent_state_channel_missing",
+    "persistent_state_attack_type_missing",
+    "persistent_state_write_case_missing",
+    "persistent_state_incorporation_case_missing",
+    "persistent_state_activation_case_missing",
+]
+
+
+RED_TEAM_MATRIX_REPAIR_PATHS = [
+    "red_team.matrix_evidence",
+    "red_team.coverage_matrix",
+    "red_team.matrix_cells",
+    "red_team.scenarios",
+    "red_team.scenarios.matrix_cell_ids",
+    "red_team.runs",
+    "red_team.runs.matrix_cell_ids",
+    "red_team.runs.execution_evidence",
+    "red_team.artifacts",
+    "red_team.artifacts.matrix_cell_ids",
+    "red_team.artifacts.execution_evidence",
+    "red_team.findings",
+    "red_team.findings.matrix_cell_ids",
+    "red_team.mitigations",
+    "red_team.mitigations.matrix_cell_ids",
+    "red_team.required_attack_types",
+    "red_team.required_surfaces",
+    "red_team.required_channels",
+    "red_team.required_providers",
+    "red_team.readiness.matrix_evidence",
+    "evaluation.red_team_campaign_quality.require_attack_surface_matrix",
+    "evaluation.red_team_campaign_quality.require_run_artifacts",
+    "evaluation.red_team_campaign_quality.require_executed_run_evidence",
+    "evaluation.red_team_campaign_quality.require_finding_mapping",
+    "evaluation.red_team_campaign_quality.require_mitigation_mapping",
+    "evaluation.red_team_campaign_quality.required_attack_matrix_cells",
+]
+
+
+OPTIMIZER_TRACE_REPAIR_PATHS = [
+    "optimizer.trace",
+    "optimizer.society_trace",
+    "optimizer.roles",
+    "optimizer.role_graph",
+    "optimizer.proposals",
+    "optimizer.credit",
+    "optimizer.diagnostics",
+    "optimizer.governance",
+    "optimizer.governance.checks",
+    "optimizer.governance.role_diversity",
+    "optimizer.governance.mediator",
+    "optimizer.governance.contract_gate",
+    "optimizer.governance.rollback",
+    "optimizer.governance.search_locality",
+    "optimizer.governance.dependency_audit",
+    "optimization",
+    "optimization.target.search_space",
+    "optimization.optimizer.max_candidates",
+    "manifest_optimization",
+    "evaluation.optimizer_trace_quality",
+    "evaluation.optimizer_trace_quality.min_role_count",
+    "evaluation.optimizer_trace_quality.min_proposal_count",
+    "evaluation.optimizer_trace_quality.min_round_count",
+    "evaluation.optimizer_trace_quality.min_credit_entries",
+    "evaluation.optimizer_trace_quality.required_roles",
+    "evaluation.optimizer_trace_quality.required_signals",
+    "evaluation.optimizer_trace_quality.required_archetypes",
+    "evaluation.optimizer_trace_quality.required_search_paths",
+    "evaluation.optimizer_trace_quality.required_governance_signals",
+    "evaluation.optimizer_trace_quality.min_governance_checks",
+    "evaluation.optimizer_trace_quality.min_governance_pass_rate",
+    "evaluation.optimizer_trace_quality.min_best_score",
+    "evaluation.optimizer_trace_quality.required_best_role",
+    "evaluation.optimizer_trace_quality.require_role_graph",
+    "evaluation.optimizer_trace_quality.require_diagnostics",
+    "evaluation.optimizer_trace_quality.require_critique",
+    "evaluation.optimizer_trace_quality.require_synthesis",
+    "evaluation.optimizer_trace_quality.require_steward",
+    "evaluation.optimizer_trace_quality.require_governance",
+    "evaluation.optimizer_trace_quality.require_role_diversity",
+    "evaluation.optimizer_trace_quality.require_mediator",
+    "evaluation.optimizer_trace_quality.require_contract_gate",
+    "evaluation.optimizer_trace_quality.require_rollback",
+    "evaluation.optimizer_trace_quality.require_locality",
+    "evaluation.optimizer_trace_quality.require_dependency_audit",
+    "evaluation.optimizer_trace_quality.max_duplicate_candidate_count",
+]
+
+
+OPTIMIZER_TRACE_FINDINGS = [
+    "missing_optimizer_trace_key",
+    "optimizer_trace_role_count_low",
+    "optimizer_trace_proposal_count_low",
+    "optimizer_trace_round_count_low",
+    "optimizer_trace_credit_low",
+    "optimizer_trace_role_missing",
+    "optimizer_trace_signal_missing",
+    "optimizer_trace_archetype_missing",
+    "optimizer_trace_search_path_missing",
+    "optimizer_trace_governance_signal_missing",
+    "optimizer_trace_governance_check_count_low",
+    "optimizer_trace_governance_pass_rate_low",
+    "optimizer_trace_best_score_low",
+    "optimizer_trace_best_role_mismatch",
+    "optimizer_trace_role_graph_missing",
+    "optimizer_trace_diagnostics_missing",
+    "optimizer_trace_critique_missing",
+    "optimizer_trace_synthesis_missing",
+    "optimizer_trace_steward_missing",
+    "optimizer_trace_governance_missing",
+    "optimizer_trace_role_diversity_missing",
+    "optimizer_trace_mediator_missing",
+    "optimizer_trace_contract_gate_missing",
+    "optimizer_trace_rollback_missing",
+    "optimizer_trace_locality_missing",
+    "optimizer_trace_dependency_audit_missing",
+    "optimizer_trace_duplicate_candidates_high",
+]
+
+
+MANIFEST_OPTIMIZATION_REPAIR_PATHS = [
+    "optimization",
+    "optimization.target",
+    "optimization.target.base_config",
+    "optimization.target.search_space",
+    "optimization.optimizer",
+    "optimization.optimizer.max_candidates",
+    "optimization.threshold",
+    "manifest_optimization",
+    "manifest_optimization.history",
+    "manifest_optimization.candidates",
+    "manifest_optimization.best_candidate_id",
+    "manifest_optimization.best_config",
+    "manifest_optimization.metrics",
+    "manifest_optimization.findings",
+    "manifest_optimization.search_paths",
+    "optimization.manifest_optimization",
+    "optimization.manifest_optimization.history",
+    "optimization.manifest_optimization.candidates",
+    "optimization.manifest_optimization.best_candidate_id",
+    "optimization.manifest_optimization.best_config",
+    "optimization.manifest_optimization.metrics",
+    "optimization.manifest_optimization.findings",
+    "optimization.manifest_optimization.search_paths",
+    "evaluation.required_manifest_optimization",
+    "evaluation.manifest_optimization",
+    "evaluation.manifest_optimization_quality",
+    "evaluation.manifest_optimization_quality.min_history_count",
+    "evaluation.manifest_optimization_quality.min_candidate_count",
+    "evaluation.manifest_optimization_quality.min_patch_count",
+    "evaluation.manifest_optimization_quality.min_metric_count",
+    "evaluation.manifest_optimization_quality.min_final_score",
+    "evaluation.manifest_optimization_quality.max_findings",
+    "evaluation.manifest_optimization_quality.required_search_paths",
+    "evaluation.manifest_optimization_quality.required_metrics",
+    "evaluation.manifest_optimization_quality.require_passed",
+    "evaluation.manifest_optimization_quality.require_best_candidate",
+    "evaluation.manifest_optimization_quality.require_best_config",
+    "evaluation.manifest_optimization_quality.require_history",
+    "evaluation.manifest_optimization_quality.require_candidate_patches",
+    "evaluation.manifest_optimization_quality.require_metrics",
+    "evaluation.manifest_optimization_quality.require_findings",
+    "evaluation.manifest_optimization_quality.require_search_paths",
+]
+
+
+MANIFEST_OPTIMIZATION_FINDINGS = [
+    "missing_manifest_optimization_key",
+    "manifest_optimization_history_count_low",
+    "manifest_optimization_candidate_count_low",
+    "manifest_optimization_patch_count_low",
+    "manifest_optimization_metric_count_low",
+    "manifest_optimization_final_score_low",
+    "manifest_optimization_findings_high",
+    "manifest_optimization_search_path_missing",
+    "manifest_optimization_metric_missing",
+    "manifest_optimization_not_passed",
+    "manifest_optimization_best_candidate_missing",
+    "manifest_optimization_best_config_missing",
+    "manifest_optimization_history_missing",
+    "manifest_optimization_candidate_patches_missing",
+    "manifest_optimization_metrics_missing",
+    "manifest_optimization_findings_missing",
+    "manifest_optimization_search_paths_missing",
+]
+
+
+FINDING_REPAIR_HINTS: Dict[str, Dict[str, Any]] = {
+    "red_team_attack_surface_cell_missing": {
+        "failure_mode": "adversarial_resilience_failure",
+        "suggested_paths": RED_TEAM_MATRIX_REPAIR_PATHS,
+        "patch_strategy": "bind every required attack surface cell to scenario evidence",
+    },
+    "red_team_run_artifact_missing": {
+        "failure_mode": "adversarial_resilience_failure",
+        "suggested_paths": RED_TEAM_MATRIX_REPAIR_PATHS,
+        "patch_strategy": "attach run artifacts to each required red-team matrix cell",
+    },
+    "red_team_run_evidence_missing": {
+        "failure_mode": "adversarial_resilience_failure",
+        "suggested_paths": RED_TEAM_MATRIX_REPAIR_PATHS,
+        "patch_strategy": "capture replayable run evidence for each red-team matrix cell",
+    },
+    "red_team_finding_mapping_missing": {
+        "failure_mode": "adversarial_resilience_failure",
+        "suggested_paths": RED_TEAM_MATRIX_REPAIR_PATHS,
+        "patch_strategy": "map red-team findings back to their attack surface matrix cells",
+    },
+    "red_team_mitigation_mapping_missing": {
+        "failure_mode": "adversarial_resilience_failure",
+        "suggested_paths": RED_TEAM_MATRIX_REPAIR_PATHS,
+        "patch_strategy": "map mitigations back to each covered red-team matrix cell",
+    },
+    **{
+        finding_type: {
+            "failure_mode": "adversarial_resilience_failure",
+            "suggested_paths": PERSISTENT_STATE_ATTACK_REPAIR_PATHS,
+            "patch_strategy": (
+                "quarantine untrusted durable writes, require provenance, "
+                "filter clean-session context rehydration, and contain "
+                "activation-time attacker instructions"
+            ),
+        }
+        for finding_type in PERSISTENT_STATE_ATTACK_FINDINGS
+    },
+    **{
+        finding_type: {
+            "failure_mode": "coordination_failure",
+            "suggested_paths": OPTIMIZER_TRACE_REPAIR_PATHS,
+            "patch_strategy": "capture optimizer society trace roles, proposals, credit, governance, and quality gates",
+        }
+        for finding_type in OPTIMIZER_TRACE_FINDINGS
+    },
+    **{
+        finding_type: {
+            "failure_mode": "coordination_failure",
+            "suggested_paths": MANIFEST_OPTIMIZATION_REPAIR_PATHS,
+            "patch_strategy": "emit manifest optimization artifacts with candidate history, patches, metrics, search paths, and passing quality gates",
+        }
+        for finding_type in MANIFEST_OPTIMIZATION_FINDINGS
+    },
+}
+
+
+def diagnose_text(text: str, *, confidence: float = 0.7) -> List[ComponentDiagnosis]:
+    lowered = text.lower()
+    diagnoses: List[ComponentDiagnosis] = []
+    for failure_mode, keywords in KEYWORD_FAILURES.items():
+        matched = [keyword for keyword in keywords if keyword in lowered]
+        if not matched:
+            continue
+        for component in FAILURE_ROUTES[failure_mode]:
+            spec = COMPONENT_SPECS[component]
+            diagnoses.append(
+                ComponentDiagnosis(
+                    component=component,
+                    failure_mode=failure_mode,
+                    confidence=confidence,
+                    evidence=f"Matched keywords: {', '.join(matched)}",
+                    suggested_paths=spec.config_paths,
+                    suggested_metrics=spec.metrics,
+                    patch_strategy=spec.patch_strategies[0] if spec.patch_strategies else None,
+                )
+            )
+    return _dedupe_diagnoses(diagnoses)
+
+
+def diagnose_report(report: Any) -> List[ComponentDiagnosis]:
+    evidence_parts: List[str] = []
+    for result in getattr(report, "results", []) or []:
+        evidence_parts.append(str(getattr(result, "transcript", "")))
+        evidence_parts.append(_jsonish(getattr(result, "evaluation", None)))
+        evidence_parts.append(_jsonish(getattr(result, "messages", None)))
+        evidence_parts.append(_jsonish(getattr(result, "tool_calls", None)))
+        evidence_parts.append(_jsonish(getattr(result, "events", None)))
+        evidence_parts.append(_jsonish(getattr(result, "metadata", None)))
+    text = "\n".join(part for part in evidence_parts if part)
+    diagnoses = diagnose_text(text)
+    if not diagnoses and text.strip():
+        diagnoses.append(
+            ComponentDiagnosis(
+                component="evaluator",
+                failure_mode="evaluation_gap",
+                confidence=0.3,
+                evidence="Report had evidence but no known failure keyword matched.",
+                suggested_paths=COMPONENT_SPECS["evaluator"].config_paths,
+                suggested_metrics=COMPONENT_SPECS["evaluator"].metrics,
+                patch_strategy="add component-specific eval coverage",
+            )
+        )
+    return diagnoses
+
+
+def diagnose_agent_report_evaluation(
+    evaluation: Any,
+    *,
+    failing_threshold: float = 0.85,
+    confidence: float = 0.85,
+) -> List[ComponentDiagnosis]:
+    payload = _model_to_plain(evaluation)
+    diagnoses: List[ComponentDiagnosis] = []
+    if not isinstance(payload, dict):
+        return diagnoses
+
+    for finding in _iter_findings(payload):
+        metric_name = str(finding.get("metric", ""))
+        finding_type = str(finding.get("type", ""))
+        repair_hint = FINDING_REPAIR_HINTS.get(finding_type)
+        failure_mode = (
+            repair_hint.get("failure_mode") if repair_hint else None
+        ) or METRIC_FAILURES.get(metric_name)
+        score = _as_float(finding.get("score"))
+        if score is not None and score >= failing_threshold and metric_name != "trial_reliability":
+            continue
+        if failure_mode:
+            diagnoses.extend(
+                _diagnoses_for_failure(
+                    failure_mode,
+                    confidence=confidence,
+                    evidence=f"{metric_name}: {_jsonish(finding)}",
+                    metadata={"metric": metric_name, "finding": finding},
+                    suggested_paths=repair_hint.get("suggested_paths") if repair_hint else None,
+                    patch_strategy=repair_hint.get("patch_strategy") if repair_hint else None,
+                )
+            )
+
+    for metric in _iter_metrics(payload):
+        metric_name = str(metric.get("name", ""))
+        failure_mode = METRIC_FAILURES.get(metric_name)
+        score = _as_float(metric.get("score", metric.get("output")))
+        if failure_mode is None or score is None or score >= failing_threshold:
+            continue
+        diagnoses.extend(
+            _diagnoses_for_failure(
+                failure_mode,
+                confidence=max(0.4, min(confidence, 1.0 - score + 0.2)),
+                evidence=(
+                    f"{metric_name} score {score:.2f} below "
+                    f"threshold {failing_threshold:.2f}: {metric.get('reason', '')}"
+                ),
+                metadata={"metric": metric_name, "score": score, "metric_result": metric},
+            )
+        )
+
+    return _dedupe_diagnoses(diagnoses)
+
+
+def relevant_search_paths(
+    search_space: Dict[str, List[Any]],
+    diagnoses: Sequence[ComponentDiagnosis],
+) -> Set[str]:
+    if not diagnoses:
+        return set(search_space.keys())
+
+    prefixes: Set[str] = set()
+    for diagnosis in diagnoses:
+        prefixes.update(diagnosis.suggested_paths)
+        prefixes.update(COMPONENT_SPECS.get(diagnosis.component, COMPONENT_SPECS["custom"]).config_paths)
+        prefixes.add(diagnosis.component)
+
+    matched = {
+        path
+        for path in search_space
+        if any(path == prefix or path.startswith(f"{prefix}.") for prefix in prefixes)
+    }
+    # Harness-layer locality (Phase 4, HarnessFix anti-broad-patch rule): layer
+    # scoping NARROWS the component-scoped set; it never widens it, and an
+    # empty intersection degrades to the component-scoped set rather than to
+    # everything. Untagged diagnoses reproduce the legacy behavior exactly.
+    layers = {
+        getattr(diagnosis, "harness_layer", None)
+        for diagnosis in diagnoses
+        if getattr(diagnosis, "harness_layer", None)
+    }
+    if layers:
+        layer_prefixes: Set[str] = set()
+        for layer in layers:
+            layer_prefixes.update(HARNESS_LAYER_PATH_PREFIXES.get(layer, ()))
+        layer_matched = {
+            path
+            for path in matched
+            if any(path == p or path.startswith(f"{p}.") for p in layer_prefixes)
+        }
+        if layer_matched:
+            return layer_matched
+    return matched or set(search_space.keys())
+
+
+def _diagnoses_for_failure(
+    failure_mode: FailureMode,
+    *,
+    confidence: float,
+    evidence: str,
+    metadata: Optional[Dict[str, Any]] = None,
+    suggested_paths: Optional[Sequence[str]] = None,
+    patch_strategy: Optional[str] = None,
+) -> List[ComponentDiagnosis]:
+    diagnoses: List[ComponentDiagnosis] = []
+    for component in FAILURE_ROUTES[failure_mode]:
+        spec = COMPONENT_SPECS[component]
+        diagnoses.append(
+            ComponentDiagnosis(
+                component=component,
+                failure_mode=failure_mode,
+                confidence=confidence,
+                evidence=evidence,
+                suggested_paths=_merge_unique(spec.config_paths, suggested_paths or []),
+                suggested_metrics=spec.metrics,
+                patch_strategy=patch_strategy or (spec.patch_strategies[0] if spec.patch_strategies else None),
+                metadata=metadata or {},
+            )
+        )
+    return diagnoses
+
+
+def _iter_findings(payload: Dict[str, Any]):
+    for finding in payload.get("findings", []) or []:
+        if isinstance(finding, dict):
+            yield finding
+    for case in payload.get("cases", []) or []:
+        if not isinstance(case, dict):
+            continue
+        for finding in case.get("findings", []) or []:
+            if isinstance(finding, dict):
+                yield finding
+        for metric in case.get("metrics", []) or []:
+            if not isinstance(metric, dict):
+                continue
+            details = metric.get("details")
+            if not isinstance(details, dict):
+                continue
+            for finding in details.get("findings", []) or []:
+                if isinstance(finding, dict):
+                    yield finding
+
+
+def _iter_metrics(payload: Dict[str, Any]):
+    for case in payload.get("cases", []) or []:
+        if not isinstance(case, dict):
+            continue
+        for metric in case.get("metrics", []) or []:
+            if isinstance(metric, dict):
+                yield metric
+
+
+def _as_float(value: Any) -> Optional[float]:
+    if isinstance(value, bool):
+        return 1.0 if value else 0.0
+    if isinstance(value, (int, float)):
+        return float(value)
+    return None
+
+
+def _dedupe_diagnoses(diagnoses: Iterable[ComponentDiagnosis]) -> List[ComponentDiagnosis]:
+    best: Dict[tuple[str, str], ComponentDiagnosis] = {}
+    for diagnosis in diagnoses:
+        key = (diagnosis.component, diagnosis.failure_mode)
+        if key not in best or diagnosis.confidence > best[key].confidence:
+            best[key] = diagnosis
+    return sorted(
+        best.values(),
+        key=lambda item: (item.confidence, item.component, item.failure_mode),
+        reverse=True,
+    )
+
+
+def _merge_unique(*groups: Iterable[str]) -> List[str]:
+    merged: List[str] = []
+    seen: Set[str] = set()
+    for group in groups:
+        for item in group:
+            if item not in seen:
+                merged.append(item)
+                seen.add(item)
+    return merged
+
+
+def _jsonish(value: Any) -> str:
+    if value is None:
+        return ""
+    try:
+        if hasattr(value, "model_dump"):
+            value = value.model_dump()
+        return json.dumps(value, default=str)
+    except Exception:
+        return str(value)
+
+
+def _model_to_plain(value: Any) -> Any:
+    if hasattr(value, "model_dump"):
+        value = value.model_dump()
+    elif hasattr(value, "dict"):
+        value = value.dict()
+    if isinstance(value, list):
+        return [_model_to_plain(item) for item in value]
+    if isinstance(value, tuple):
+        return [_model_to_plain(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _model_to_plain(item) for key, item in value.items()}
+    if hasattr(value, "__dict__"):
+        return {key: _model_to_plain(item) for key, item in vars(value).items()}
+    return value