"""Shared typed quant runtime used by Slack and the browser YOLO entry.""" from __future__ import annotations import inspect from collections.abc import Awaitable, Callable, Mapping, Sequence from dataclasses import dataclass from datetime import datetime, timezone from typing import Any from pydantic import BaseModel from polyhedra.agents.base import AgentResponse from polyhedra.agents.quant.asset_contracts import ( AssetAnalysisCollection, BTCAnalystOutput, GLDAnalystOutput, QQQAnalystOutput, SPYAnalystOutput, ) from polyhedra.agents.quant.decision_contracts import CommitteePerformance from polyhedra.agents.quant.io_registry import quant_artifact_schema, quant_io_binding from polyhedra.agents.quant.market_data_contracts import MarketDataArtifact from polyhedra.agents.quant.product_contracts import PublisherOutput from polyhedra.core.active_routing import ActiveAgentPlan, build_active_routing_plan from polyhedra.core.artifacts import JsonArtifactRef, RunMode from polyhedra.core.baseline_selector import BaselineSelection, select_typed_yolo_baseline from polyhedra.core.dependency_executor import ( AgentCompletion, AgentExecutionState, DependencyExecutionResult, DependencyExecutor, ) from polyhedra.core.quant_contracts import AgentName, ExecutionContext, load_quant_contracts from polyhedra.core.research_state import ResearchStateManager from polyhedra.core.state_patcher import StatePatcher from polyhedra.core.trace_logger import TraceLogger from polyhedra.services.artifact_publisher import ArtifactPublisher from polyhedra.services.asset_analysis_collection import build_asset_analysis_collection from polyhedra.services.evidence_ledger import write_typed_evidence_ledger from polyhedra.services.error_sanitizer import sanitize_exception from polyhedra.services.file_writer import FileWriter, PublicationRegistry, ScopedFileWriter from polyhedra.services.llm_service import StructuredOutputError from polyhedra.services.published_inputs import ActivationArtifactSnapshot, PublishedInputResolver from polyhedra.services.quant_run_record import ( QuantRunRecord, QuantRunRecordStore, QuantRunStatus, build_quant_run_record, ) from polyhedra.services.strategist_performance import StrategistPerformanceTracker ProgressFn = Callable[[AgentName, AgentExecutionState, str], Awaitable[None]] BeforeAgentFn = Callable[[AgentName, BaseModel], Awaitable[None]] @dataclass(frozen=True) class QuantRuntimeResult: record: QuantRunRecord finley: PublisherOutput | None baseline: BaselineSelection @dataclass(frozen=True) class _Activation: inputs: BaseModel files: ScopedFileWriter class QuantRuntime: """Execute existing quant agents from the packaged routing and ACL tables.""" def __init__( self, *, session_dir, session_id: str, agents: Mapping[AgentName, Any], writer: FileWriter, trace: TraceLogger, progress: ProgressFn | None = None, before_agent: BeforeAgentFn | None = None, ) -> None: self._session_dir = session_dir self._session_id = session_id self._agents = dict(agents) self._writer = writer self._trace = trace self._progress = progress self._before_agent = before_agent self._patcher = StatePatcher() self._publications = PublicationRegistry() self._outputs: dict[AgentName, BaseModel] = {} self._asset_collection_ref: JsonArtifactRef | None = None self._input_paths: dict[AgentName, str] = {} self._research_state: dict[str, Any] = {} self._selection: BaselineSelection | None = None self._publisher: ArtifactPublisher | None = None self._as_of: datetime | None = None async def run_yolo( self, *, run_id: str, tickers: list[str], started_at: datetime | None = None, ) -> QuantRuntimeResult: """Run the frozen YOLO graph and persist its immutable typed record.""" self._as_of = started_at or datetime.now(tz=timezone.utc) store = QuantRunRecordStore(self._session_dir, session_id=self._session_id) self._selection = select_typed_yolo_baseline( store.baseline_candidates(), session_id=self._session_id, current_run_id=run_id, ticker_scope=tickers, ) for reference in self._selection.baseline_artifacts: self._publications.publish(reference.path, reference) plan = build_active_routing_plan( run_id=run_id, execution_context=ExecutionContext.YOLO, tickers=tickers, ) missing = {item.agent for item in plan.active_agents} - set(self._agents) if missing: raise RuntimeError(f"active quant agents are not registered: {', '.join(sorted(missing))}") self._publisher = ArtifactPublisher( self._writer, session_id=self._session_id, run_id=run_id, ) self._research_state = ResearchStateManager(self._session_dir).load().to_dict() self._update_run_state() executor = DependencyExecutor( plan, session_id=self._session_id, runner=self._run_agent, input_capture=self._capture_input, ) execution = await executor.run() await self._report_blocked(execution) completed_at = datetime.now(tz=timezone.utc) additional = [ reference for reference in self._publications.references() if reference.run_id == run_id ] record = build_quant_run_record( plan=plan, execution=execution, session_id=self._session_id, run_mode=self._selection.run_mode, baseline_run_id=self._selection.baseline_run_id, started_at=self._as_of, completed_at=completed_at, input_snapshot_paths=dict(self._input_paths), permission_templates=self._permission_templates(plan), permission_snapshots=self._permission_snapshots(plan), additional_artifacts=_unique_additional_artifacts(execution, additional), ) write_typed_evidence_ledger(self._session_dir, record) store.save(record) self._persist_state(record, completed_at) finley = self._outputs.get("Publisher") return QuantRuntimeResult( record=record, finley=finley if isinstance(finley, PublisherOutput) else None, baseline=self._selection, ) def _capture_input( self, item: ActiveAgentPlan, dependencies, ) -> _Activation: if item.agent == "QuantResearcher": self._publish_asset_collection(item) files = self._scoped_files(item) readable = set(files.readable_paths()) required_refs = tuple( record.artifact_ref for record in dependencies if record.artifact_ref is not None and record.artifact_ref.path in readable ) snapshot = PublishedInputResolver(files).capture(required_refs=required_refs) inputs = self._build_input(item, snapshot, files) return _Activation(inputs=inputs, files=files) async def _run_agent( self, item: ActiveAgentPlan, activation: _Activation, ) -> AgentCompletion: if self._publisher is None: raise RuntimeError("quant runtime publisher is not initialized") agent = self._agents[item.agent] if self._before_agent is not None: await self._before_agent(item.agent, activation.inputs) await self._notify(item.agent, AgentExecutionState.RUNNING, "") trace_id = self._trace.start_run( getattr(agent, "role", item.agent), prompt=activation.inputs.model_dump_json(), session_id=self._session_id, ) token_log = _token_log(self._research_state) role = getattr(agent, "role", item.agent) role_count = sum(entry.get("agent_role") == role for entry in token_log) try: kwargs: dict[str, Any] = { "files": activation.files, "publisher": self._publisher, } signature = inspect.signature(agent.execute_typed) if "research_state" in signature.parameters: kwargs["research_state"] = self._research_state completion = await agent.execute_typed(activation.inputs, **kwargs) output = self._load_output(completion.artifact_ref) self._outputs[item.agent] = output self._input_paths[item.agent] = ( f"quant/runs/{completion.artifact_ref.run_id}/inputs/{item.agent}.json" ) if item.agent == "QuantStrategist": self._record_committee(output, activation.files) usage = [ entry for entry in _token_log(self._research_state) if entry.get("agent_role") == role ][role_count:] response = AgentResponse( agent_role=role, content=output.model_dump_json(), artifact_path=completion.artifact_ref.path, output=output, ) self._trace.end_run( trace_id, response, prompt_tokens=sum(int(entry.get("prompt_tokens", 0)) for entry in usage), completion_tokens=sum(int(entry.get("completion_tokens", 0)) for entry in usage), estimated_cost_usd=sum(float(entry.get("estimated_cost_usd", 0)) for entry in usage), ) await self._notify(item.agent, AgentExecutionState.COMPLETED, completion.result_status) return completion except BaseException as exc: safe_error = sanitize_exception(exc) response = AgentResponse( agent_role=role, content=safe_error, error=safe_error, ) usage = [ entry for entry in _token_log(self._research_state) if entry.get("agent_role") == role ][role_count:] prompt_tokens = sum(int(entry.get("prompt_tokens", 0)) for entry in usage) completion_tokens = sum(int(entry.get("completion_tokens", 0)) for entry in usage) if isinstance(exc, StructuredOutputError): prompt_tokens += exc.input_tokens completion_tokens += exc.output_tokens self._trace.end_run( trace_id, response, prompt_tokens=prompt_tokens, completion_tokens=completion_tokens, estimated_cost_usd=None, ) await self._notify(item.agent, AgentExecutionState.FAILED, safe_error) raise def _build_input( self, item: ActiveAgentPlan, snapshot: ActivationArtifactSnapshot, files: ScopedFileWriter, ) -> BaseModel: if self._selection is None or self._as_of is None: raise RuntimeError("quant runtime input context is not initialized") current = [*snapshot.required, *snapshot.optional] baseline = list(snapshot.baseline) output = lambda producer: _agent_output(current, producer) prior = lambda producer: _agent_output(baseline, producer) markets = lambda scope: [ loaded.value for loaded in current if isinstance(loaded.value, MarketDataArtifact) and loaded.value.ticker in scope ] refs = [loaded.reference for loaded in baseline] scope = list(item.effective_ticker_scope) common: dict[str, Any] = { "run_id": self._selection.current_run_id, "session_id": self._session_id, "run_mode": self._selection.run_mode, "as_of": self._as_of, "ticker_scope": scope, } agent = item.agent if agent == "DataFetcher": raw = { loaded.value.ticker: loaded.reference for loaded in baseline if isinstance(loaded.value, MarketDataArtifact) and loaded.value.ticker in scope } data = {**common, "baseline_refs": raw} else: data = {**common, "baseline_refs": refs} if agent == "OptionsFlowWatcher": data.update(dependencies={}, optional_context={"provider_fetch_cutoff": self._as_of}) elif agent == "TrendAnalyst": data.update( dependencies={"data_fetch": output("DataFetcher"), "market_data": markets(scope)}, optional_context={"prior_trend": prior("TrendAnalyst")}, ) elif agent in {"SentimentAnalyst", "MarketEventWatcher"}: prior_name = "SentimentAnalyst" if agent == "SentimentAnalyst" else "MarketEventWatcher" prior_field = "prior_sentiment" if agent == "SentimentAnalyst" else "prior_market_events" data.update( dependencies={"data_fetch": output("DataFetcher"), "market_data": markets(scope)}, optional_context={ "current_trend": output("TrendAnalyst"), prior_field: prior(prior_name), }, ) elif agent == "MacroContextWatcher": data.update( dependencies={ "market_events": output("MarketEventWatcher"), "options_flow": output("OptionsFlowWatcher"), }, optional_context={"prior_macro": prior("MacroContextWatcher")}, ) elif agent == "UnusualEventDetector": data.update( dependencies={ "market_events": output("MarketEventWatcher"), "macro_context": output("MacroContextWatcher"), "options_flow": output("OptionsFlowWatcher"), }, optional_context={"prior_events": prior("UnusualEventDetector")}, ) elif agent == "EventRouter": data.update( dependencies={"unusual_events": output("UnusualEventDetector")}, optional_context={ "market_events": output("MarketEventWatcher"), "options_flow": output("OptionsFlowWatcher"), "prior_route": prior("EventRouter"), }, ) elif agent in {"BTCAnalyst", "SPYAnalyst", "QQQAnalyst", "GLDAnalyst"}: scoped_sentiment = output("SentimentAnalyst") if ( scoped_sentiment is not None and not set(scope).intersection(scoped_sentiment.ticker_scope) ): scoped_sentiment = None data.update( dependencies={ "trend": output("TrendAnalyst"), "event_route": output("EventRouter"), }, optional_context={ "market_events": output("MarketEventWatcher"), "options_flow": None if agent == "BTCAnalyst" else output("OptionsFlowWatcher"), "macro_context": output("MacroContextWatcher"), "unusual_events": output("UnusualEventDetector"), "sentiment": scoped_sentiment, }, ) elif agent == "QuantResearcher": data.update( dependencies={ "trend": output("TrendAnalyst"), "sentiment": output("SentimentAnalyst"), "asset_analyses": _runtime_collection(current), }, optional_context={ "macro_context": output("MacroContextWatcher"), "unusual_events": output("UnusualEventDetector"), }, ) elif agent == "Backtester": data.update( dependencies={"signals": output("QuantResearcher")}, optional_context={"market_data": markets(scope)}, ) elif agent == "RiskAnalyst": data.update( dependencies={"backtests": output("Backtester")}, optional_context={ "trend": output("TrendAnalyst"), "asset_analyses": _runtime_collection(current), "macro_context": output("MacroContextWatcher"), "open_positions": self._risk_positions(scope), }, ) elif agent == "QuantStrategist": tracker = StrategistPerformanceTracker.load( files.for_trusted_performance_tool() ) data.update( dependencies={"risk": output("RiskAnalyst")}, optional_context={ "signals": output("QuantResearcher"), "backtests": output("Backtester"), "sentiment": output("SentimentAnalyst"), "asset_analyses": _runtime_collection(current), "macro_context": output("MacroContextWatcher"), "committee_performance": CommitteePerformance( weights=tracker.current_weights(), recorded_at=self._as_of, ), }, ) elif agent == "Publisher": data.update( dependencies={"strategy": output("QuantStrategist")}, optional_context={ "trend": output("TrendAnalyst"), "sentiment": output("SentimentAnalyst"), "risk": output("RiskAnalyst"), "asset_analyses": _runtime_collection(current), "macro_context": output("MacroContextWatcher"), }, ) else: raise ValueError(f"{agent} is not a YOLO agent") return quant_io_binding(agent).input_schema.model_validate(data) def _scoped_files(self, item: ActiveAgentPlan) -> ScopedFileWriter: if self._selection is None: raise RuntimeError("baseline selection is unavailable") return ScopedFileWriter( self._writer, agent=item.agent, run_id=self._selection.current_run_id, ticker_scope=list(item.effective_ticker_scope), baseline_run_id=self._selection.baseline_run_id, publications=self._publications, ) def _load_output(self, reference: JsonArtifactRef) -> BaseModel: raw = self._writer.read(reference.path) if raw is None: raise FileNotFoundError(reference.path) return quant_artifact_schema(reference.producer).model_validate_json(raw, strict=True) def _publish_asset_collection(self, item: ActiveAgentPlan) -> None: if self._asset_collection_ref is not None: return specialized = [ticker for ticker in item.effective_ticker_scope if ticker in {"BTC", "SPY", "QQQ", "GLD"}] if not specialized: return if self._selection is None: raise RuntimeError("baseline selection is unavailable") outputs = [ value for value in self._outputs.values() if isinstance(value, (BTCAnalystOutput, SPYAnalystOutput, QQQAnalystOutput, GLDAnalystOutput)) and value.ticker_scope[0] in specialized ] collection = build_asset_analysis_collection( run_id=self._selection.current_run_id, session_id=self._session_id, created_at=datetime.now(tz=timezone.utc), ticker_scope=specialized, outputs=outputs, publications=self._publications, ) path = f"quant/runs/{self._selection.current_run_id}/asset_analysis.json" self._writer.write_atomic(path, collection.model_dump_json(indent=2), agent_role="Runtime") reference = JsonArtifactRef( schema_version="8.0", artifact_id=collection.artifact_id, run_id=collection.run_id, session_id=collection.session_id, producer="Runtime", path=path, ) self._publications.publish(path, reference) self._asset_collection_ref = reference def _risk_positions(self, scope: Sequence[str]) -> list[dict[str, Any]]: quant = self._research_state.get("quant_state") or {} positions = [] for position in quant.get("portfolio") or []: if position.get("status", "open") != "open" or position.get("ticker") not in scope: continue positions.append({ "position_id": position["position_id"], "ticker": position["ticker"], "direction": str(position["direction"]).upper(), "entry_price": float(position["entry_price"]), "portfolio_fraction": float(position["size_pct"]) / 100.0, }) return positions def _record_committee(self, output: BaseModel, files: ScopedFileWriter) -> None: payload = output.payload trusted_files = files.for_trusted_performance_tool() tracker = StrategistPerformanceTracker.load(trusted_files) votes = [ { "member_id": vote.member_id, "vote": vote.vote.value, "confidence": vote.confidence.value, "rationale": vote.thesis, "evidence_used": [item.model_dump(mode="json") for item in vote.cited_evidence], "proposal_impact": vote.proposal_impact, } for vote in payload.committee_votes ] result = tracker.record_votes( trusted_files, votes, run_mode=self._selection.run_mode.value if self._selection else "BASELINE", outcome=payload.outcome.value, ) quant = self._research_state.get("quant_state") if not isinstance(quant, dict): quant = {} self._research_state["quant_state"] = quant quant["strategist_committee_votes"] = tracker.vote_history quant["strategist_committee_weights"] = result["weights"] quant["strategist_weight_updates"] = result["weight_updates"] quant["strategist_proposal_updates"] = [ item.model_dump(mode="json") for item in payload.proposal_updates ] quant["trade_proposals_raw"] = [ item.model_dump(mode="json") for item in payload.proposals ] def _update_run_state(self) -> None: if self._selection is None or self._as_of is None: return self._patcher.apply(self._session_dir, { "yolo_run_mode": ( "session_delta" if self._selection.run_mode == RunMode.DELTA else "baseline" ), "yolo_run_id": self._selection.current_run_id, "yolo_run_started_at": self._as_of.isoformat(), "yolo_baseline_complete": self._selection.baseline_run_id is not None, "yolo_baseline_artifacts": { reference.producer: reference.path for reference in self._selection.baseline_artifacts }, "yolo_missing_baseline_artifacts": list(self._selection.missing_tickers), }) def _persist_state(self, record: QuantRunRecord, completed_at: datetime) -> None: quant = self._research_state.get("quant_state") or {} patch = { key: quant[key] for key in ( "token_log", "trade_proposals_raw", "strategist_committee_votes", "strategist_committee_weights", "strategist_weight_updates", "strategist_proposal_updates", ) if key in quant } if record.status == QuantRunStatus.COMPLETED: patch["yolo_last_completed_at"] = completed_at.isoformat() self._patcher.apply(self._session_dir, patch) def _permission_snapshots(self, plan) -> dict[AgentName, dict[str, list[str]]]: baseline_run_id = self._selection.baseline_run_id if self._selection else None contracts = load_quant_contracts() snapshots: dict[AgentName, dict[str, list[str]]] = {} for item in plan.active_agents: permissions = contracts.for_agent(item.agent).permissions.model_dump(mode="json") resolved: dict[str, list[str]] = {} for operation, templates in permissions.items(): paths: list[str] = [] selected_run = baseline_run_id if operation.startswith("baseline_") else plan.run_id for template in templates: if not selected_run and "{baseline_run_id}" in template: continue path = template.replace("{run_id}", selected_run or "").replace( "{baseline_run_id}", selected_run or "", ) if "{ticker}" in path: paths.extend( path.replace("{ticker}", ticker) for ticker in item.effective_ticker_scope ) else: paths.append(path) resolved[operation] = paths snapshots[item.agent] = resolved return snapshots def _permission_templates(self, plan) -> dict[AgentName, dict[str, list[str]]]: contracts = load_quant_contracts() return { item.agent: contracts.for_agent(item.agent).permissions.model_dump(mode="json") for item in plan.active_agents } async def _report_blocked(self, execution: DependencyExecutionResult) -> None: for record in execution.records: if record.state == AgentExecutionState.BLOCKED: await self._notify( record.agent, record.state, ", ".join(record.blocked_by), ) async def _notify(self, agent: AgentName, state: AgentExecutionState, detail: Any) -> None: if self._progress is not None: await self._progress(agent, state, str(detail or "")) def _agent_output(loaded, producer: str) -> BaseModel | None: for item in loaded: if item.reference.producer != producer: continue if producer == "DataFetcher" and isinstance(item.value, MarketDataArtifact): continue if producer != "Runtime" and isinstance(item.value, quant_artifact_schema(producer)): return item.value return None def _runtime_collection(loaded) -> AssetAnalysisCollection | None: return next( (item.value for item in loaded if isinstance(item.value, AssetAnalysisCollection)), None, ) def _token_log(state: dict[str, Any]) -> list[dict[str, Any]]: quant = state.get("quant_state") if not isinstance(quant, dict): quant = {} state["quant_state"] = quant return quant.setdefault("token_log", []) def _unique_additional_artifacts( execution: DependencyExecutionResult, references, ) -> list: completed = { record.artifact_ref.path for record in execution.records if record.artifact_ref is not None } seen = set(completed) additional = [] for reference in references: if reference.path in seen: continue seen.add(reference.path) additional.append(reference) return additional