Beau ten Berge

def _source_expansion_requested_sources_schema(registry: Any) -> Dict[str, Any]:
    source_registry = _source_expansion_registry(registry)
    item_schema = registry._string_schema("Source key from SourceExpansionRegistry.")
    item_schema["enum"] = source_registry.source_key_enum(include_optional=True)

    return registry._array_schema(
        item_schema,
        source_registry.requested_sources_description(include_optional=True),
    )


def build_registry_specs(registry: Any) -> Dict[str, ToolSpec]:
    specs = {
        **build_identity_specs(registry),
        **build_profile_specs(registry),
        **build_activity_specs(registry),
        **build_exposure_specs(registry),
        **build_infrastructure_specs(registry),
    }
    validate_tool_catalog_coverage(specs)
    return specs

class GraphActionStatus(str, Enum):
    QUEUED = "queued"
    RUNNING = "running"
    SUCCEEDED = "succeeded"
    NO_HIT = "no_hit"
    FAILED = "failed"
    RATE_LIMITED = "rate_limited"
    SKIPPED = "skipped"


class GraphActionQueue:
    """Graph action queue with durable deduplication."""

    OPEN_STATUSES = (
        GraphActionStatus.QUEUED,
        GraphActionStatus.RUNNING,
        GraphActionStatus.RATE_LIMITED,
    )
    TERMINAL_STATUSES = (
        GraphActionStatus.SUCCEEDED,
        GraphActionStatus.NO_HIT,
        GraphActionStatus.FAILED,
        GraphActionStatus.SKIPPED,
    )

def _evidence_court_ceiling(self, memory: Any) -> tuple[float, str]:
    try:
        verdicts = self.EVIDENCE_COURT.evaluate(memory)
        return self.EVIDENCE_COURT.confidence_ceiling(verdicts)
    except Exception as exc:
        logger.debug("confidence_engine suppressed error: %s", exc)
        return (
            self.EVIDENCE_COURT_FAIL_CLOSED_CEILING,
            "Evidence Court could not evaluate all evidence safely; "
            "applying conservative confidence ceiling.",
        )


def _explain(self, breakdown: dict[str, float], gate: str, reason: str = "") -> str:
    signals = [f"{name}: {value:.1f}" for name, value in breakdown.items() if value > 0]
    suffix = f" Evidence Court: {reason}" if reason else ""
    return f"Gate: {gate}. Signals: {', '.join(signals) or 'none'}.{suffix}"

async def run(
    self,
    *,
    profile: dict[str, Any] | None = None,
    requested_sources: list[str] | None = None,
    existing_coverage: dict[str, Any] | None = None,
    memory: Any = None,
) -> dict[str, Any]:
    clean_profile = dict(profile or {})
    if existing_coverage is not None:
        clean_profile["existing_coverage"] = existing_coverage

    planned = self._sources_for(clean_profile, requested_sources)
    results = [
        await self._run_source(source, clean_profile, existing_coverage or {}, memory)
        for source in planned
    ]
    data = self._aggregate_results(results)
    return {
        "source": "source_expansion_intel",
        "status": self._overall_status(results, data),
        "executed_sources": [result.source for result in results],
        "suggested_next_tools": self._suggest_next_tools(data),
    }