ilc-core 0.1.0__py3-none-any.whl

ilc_core/agent.py

@@ -0,0 +1,273 @@
+from typing import Optional
+import logging
+from decimal import Decimal, InvalidOperation
+from .types import Node
+from .graph import EpistemicGraph
+from .exceptions import InsufficientStakeError
+from .consensus.engine import ConsensusEngine
+from .mining.benchmark import PoWBenchmark
+from .economics.onboarding import OnboardingVault
+from .identity.log_redaction_runtime import redact_agent_id_for_log
+import time
+
+logger = logging.getLogger(__name__)
+
+DRAFT_SIGNATURE = "draft_unsigned_mvp"
+
+class EveAgent:
+    def __init__(self, agent_id: str, graph: EpistemicGraph, consensus: ConsensusEngine, vault: Optional[OnboardingVault] = None):
+        self.id = agent_id
+        self.graph = graph
+        self.consensus = consensus
+        self.vault = vault
+        
+        self.wallet_balance = Decimal("0")
+        self.credit_balance = Decimal("0")
+        
+        # Onboarding: Request Credit if Vault exists
+        if self.vault:
+            credit = self.vault.request_starter_credit(self.id)
+            self.credit_balance += credit
+            self.wallet_balance += credit # Credit is liquid for staking
+
+        self.benchmark_engine = PoWBenchmark(matrix_size=1000)
+        self.trust_vector = {
+            "accuracy": 0.5,
+            "precision": 0.5,
+            "potential": 0.0,
+            "tier": "unknown"
+        }
+
+    def decide_stake_for_claim(self, requested_stake: Decimal) -> Decimal:
+        """
+        Decide how much to stake for a claim.submit task.
+
+        MVP behavior (backwards-compatible):
+        - Query the current ECU fee for "claim.submit" from Governance.
+        - Ensure the chosen stake is at least the ECU fee.
+        - Never exceed the agent's wallet_balance.
+        - If requested_stake >= required_fee and <= wallet_balance, keep it unchanged.
+          (This preserves existing tests that pass explicit stakes like 5.0 or 10.0.)
+        - If requested_stake < required_fee but wallet can afford required_fee, bump up
+          to exactly required_fee.
+        - If wallet_balance < required_fee, return 0.0 to signal "cannot stake".
+        """
+        self._normalize_balances()
+        stake_amount = _agent_coerce_decimal(requested_stake, "agent_requested_stake_invalid")
+        if stake_amount < Decimal("0"):
+            raise InsufficientStakeError(
+                self.id,
+                stake=stake_amount,
+                required=Decimal("0"),
+                message="requested_stake cannot be negative",
+            )
+
+        # Ask consensus governance for current ECU fee.
+        required_fee = self.consensus.governance.get_task_fee_ecu("claim.submit")
+        min_required = required_fee
+
+        # Wallet cannot afford even the minimum fee → no staking.
+        if self.wallet_balance < min_required:
+            return Decimal("0")
+
+        # Preserve explicit stakes from callers if they are sane.
+        if stake_amount >= min_required and stake_amount <= self.wallet_balance:
+            return stake_amount
+
+        # If requested stake is below the required fee, bump up to exactly the fee
+        # as long as the wallet can pay.
+        if stake_amount < min_required and self.wallet_balance >= min_required:
+            return min_required
+
+        # If requested stake is more than wallet_balance, cap at wallet_balance.
+        if stake_amount > self.wallet_balance:
+            return self.wallet_balance
+
+        # Fallback: refuse to stake in any weird edge case.
+        return Decimal("0")
+
+    def perform_pow_benchmark(self) -> float:
+        """
+        Run a hardware / PoW-style benchmark and update this agent's
+        trust_vector["potential"].
+
+        The resulting score ∈ [0, 1] is used as a proxy for hardware capability
+        (and, in future phases, can inform how aggressively the agent chooses
+        to spend stake on ILC tasks).
+        """
+        # Preserving Phase H Logic
+        result = self.benchmark_engine.run(self.id)
+        self.trust_vector["potential"] = result["score"]
+        self.trust_vector["tier"] = result["tier"]
+        logger.info(
+            "agent_hardware_verified agent=%s device=%s tier=%s",
+            redact_agent_id_for_log(self.id),
+            result["device"],
+            result["tier"],
+        )
+        return result["score"]
+
+    def mine_thought(self, content: str, parent_id: str, stake: Decimal) -> Optional[Node]:
+        """
+        Mine a new claim node linked to parent_id, staking some amount of
+        the agent's wallet balance.
+
+        This MVP version now routes the requested stake through
+        decide_stake_for_claim(...) to ensure we at least pay the ECU fee
+        and never exceed wallet_balance.
+        """
+        # Decide how much we can/should actually stake given ECU fees + wallet.
+        chosen_stake = self.decide_stake_for_claim(stake)
+
+        # If we cannot stake anything meaningful, abort with the existing message.
+        if chosen_stake <= Decimal("0") or self.wallet_balance < chosen_stake:
+            logger.warning(
+                "agent_stake_insufficient_funds agent=%s wallet=%s chosen=%s",
+                redact_agent_id_for_log(self.id),
+                self.wallet_balance,
+                chosen_stake,
+            )
+            return None
+
+        # Construct the node exactly as before.
+        node = Node(
+            id="",
+            type="claim",
+            content=content,
+            agent_id=self.id,
+            signature=DRAFT_SIGNATURE,
+        )
+        node.id = node.compute_id()
+        self.graph.add_node(node)
+        self.graph.add_edge_by_ids(node.id, parent_id, "derives_from")
+
+        # Deduct the chosen stake and register it with the consensus engine.
+        self.wallet_balance -= chosen_stake
+        success = self.consensus.register_stake(node.id, chosen_stake)
+        if not success:
+            # In case governance rejects the stake (e.g., ECU fee changed mid-flight),
+            # revert the wallet deduction and abort.
+            self.wallet_balance += chosen_stake
+            logger.warning(
+                "agent_stake_rejected_by_consensus agent=%s chosen=%s",
+                redact_agent_id_for_log(self.id),
+                chosen_stake,
+            )
+            return None
+
+        logger.info(
+            "agent_claim_minted agent=%s node=%s",
+            redact_agent_id_for_log(self.id),
+            node.id[:8],
+        )
+        return node
+
+    def auto_mine_claim(self, content: str, parent_id: str) -> Optional[Node]:
+        """
+        Strategy helper: automatically choose a stake for a claim.submit task
+        based on:
+        - current wallet_balance,
+        - the ECU fee for "claim.submit" (via Governance),
+        - this agent's hardware potential (trust_vector["potential"]).
+
+        This is primarily intended for simulations and does not change the
+        behavior of mine_thought(...) when called directly with an explicit
+        stake.
+
+        MVP strategy:
+        - Ensure we have a hardware potential score (run perform_pow_benchmark()
+          if needed).
+        - Map potential ∈ [0, 1] to a stake fraction ∈ [f_min, f_max] of the
+          current wallet_balance.
+        - Compute candidate_stake = fraction * wallet_balance.
+        - Route candidate_stake through decide_stake_for_claim(...) to enforce
+          ECU fees and wallet caps.
+        - If the resulting stake is valid, call mine_thought(...) with that
+          chosen stake.
+        """
+        # Ensure we have a potential measurement.
+        self._normalize_balances()
+        if self.trust_vector.get("potential", 0.0) <= 0.0:
+            self.perform_pow_benchmark()
+
+        potential = self.trust_vector.get("potential", 0.0)
+
+        # Low potential → more cautious; high potential → more aggressive.
+        # Allow external config (e.g., hardware archetypes) to override.
+        f_min = getattr(self, "strategy_stake_fraction_min", 0.05)
+        f_max = getattr(self, "strategy_stake_fraction_max", 0.25)
+        frac = f_min + (f_max - f_min) * potential
+
+        # Derive a candidate stake from current wallet.
+        candidate_stake = Decimal(str(frac)) * self.wallet_balance
+
+        # Let the ECU-aware helper adjust or reject.
+        chosen = self.decide_stake_for_claim(candidate_stake)
+
+        if chosen <= Decimal("0") or self.wallet_balance < chosen:
+            logger.warning(
+                "agent_auto_mine_aborted agent=%s wallet=%s chosen=%s",
+                redact_agent_id_for_log(self.id),
+                self.wallet_balance,
+                chosen,
+            )
+            return None
+
+        # Delegate actual minting to the existing mine_thought path.
+        return self.mine_thought(content, parent_id, chosen)
+
+    def receive_reward(self, amount: Decimal):
+        """Handle earnings and auto-repayment."""
+        self._normalize_balances()
+        reward_amount = _agent_coerce_decimal(amount, "agent_reward_invalid")
+        if self.vault:
+            repayment, net = self.vault.process_repayment(self.id, reward_amount)
+            self.wallet_balance += net
+            # Credit balance is technically liability, but simplistic tracking here:
+            if repayment > Decimal("0"):
+                logger.info(
+                    "agent_reward_repayment agent=%s repaid=%s net=%s",
+                    redact_agent_id_for_log(self.id),
+                    repayment,
+                    net,
+                )
+        else:
+            self.wallet_balance += reward_amount
+
+    def refute_node(self, target_id: str, stake: Decimal):
+        self._normalize_balances()
+        stake_amount = _agent_coerce_decimal(stake, "agent_refutation_stake_invalid")
+        if self.wallet_balance < stake_amount:
+            logger.warning(
+                "agent_refute_insufficient_balance agent=%s target=%s wallet=%s stake=%s",
+                redact_agent_id_for_log(self.id),
+                target_id,
+                self.wallet_balance,
+                stake_amount,
+            )
+            return False
+        self.wallet_balance -= stake_amount
+        self.consensus.process_contradiction(target_id, stake_amount)
+        return True
+
+    def _normalize_balances(self) -> None:
+        self.wallet_balance = _agent_coerce_decimal(
+            self.wallet_balance, "agent_wallet_balance_invalid"
+        )
+        self.credit_balance = _agent_coerce_decimal(
+            self.credit_balance, "agent_credit_balance_invalid"
+        )
+
+
+def _agent_coerce_decimal(value: object, token: str) -> Decimal:
+    if isinstance(value, bool):
+        raise ValueError(token)
+    if not isinstance(value, (Decimal, int, float, str)):
+        raise ValueError(token)
+    try:
+        amount = value if isinstance(value, Decimal) else Decimal(str(value))
+    except (InvalidOperation, ValueError) as exc:
+        raise ValueError(token) from exc
+    if not amount.is_finite():
+        raise ValueError(f"{token}_non_finite")
+    return amount

ilc_core/analysis/agent_descriptors.py

@@ -0,0 +1,93 @@
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, TypeAlias
+from os import PathLike
+from pathlib import Path
+import csv
+
+from ilc_core.analysis.problem_space_kpis import (
+    ProblemSpace,
+    compute_problem_space_kpis,
+)
+
+
+AgentDescriptorRow: TypeAlias = Dict[str, str | float]
+
+@dataclass
+class AgentDescriptor:
+    """
+    Lightweight descriptor of an agent's behavior across problem spaces.
+    """
+    agent_id: str
+    problem_space_counts: Dict[str, float] = field(default_factory=dict)
+    total_tasks: float = 0.0
+    dominant_problem_space: str = "OTHER"
+
+    def as_dict(self) -> AgentDescriptorRow:
+        data = {
+            "agent_id": self.agent_id,
+            "total_tasks": self.total_tasks,
+            "dominant_problem_space": self.dominant_problem_space,
+        }
+        # Flatten counts with a prefix for clarity.
+        for space, count in self.problem_space_counts.items():
+            data[f"space_{space}"] = count
+        return data
+
+
+def build_agent_descriptors_from_task_rows(
+    task_rows: List[Dict[str, str]],
+) -> Dict[str, AgentDescriptor]:
+    """
+    Build AgentDescriptors from in-memory task rows.
+    """
+    space_kpis = compute_problem_space_kpis(task_rows)
+    descriptors: Dict[str, AgentDescriptor] = {}
+
+    for agent_id, stats in space_kpis.items():
+        total_tasks = stats.get("total_tasks", 0.0)
+
+        # Extract per-space counts (excluding total_tasks).
+        problem_space_counts = {
+            k: v for k, v in stats.items() if k != "total_tasks"
+        }
+
+        # Identify dominant problem space (ties broken arbitrarily by max).
+        if problem_space_counts:
+            dominant_space = max(problem_space_counts.items(), key=lambda kv: kv[1])[0]
+        else:
+            dominant_space = "OTHER"
+
+        descriptors[agent_id] = AgentDescriptor(
+            agent_id=agent_id,
+            problem_space_counts=problem_space_counts,
+            total_tasks=total_tasks,
+            dominant_problem_space=dominant_space,
+        )
+
+    return descriptors
+
+
+def load_tasks_csv(path: PathLike) -> List[Dict[str, str]]:
+    """
+    Convenience loader for tasks.csv to feed into descriptor builders.
+    """
+    p = Path(path)
+    rows: List[Dict[str, str]] = []
+    if not p.exists():
+        return rows
+
+    with p.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            rows.append(dict(row))
+    return rows
+
+
+def build_agent_descriptors_from_tasks_csv(
+    tasks_csv_path: PathLike,
+) -> Dict[str, AgentDescriptor]:
+    """
+    High-level helper: load tasks.csv and build AgentDescriptors.
+    """
+    rows = load_tasks_csv(tasks_csv_path)
+    return build_agent_descriptors_from_task_rows(rows)

ilc_core/analysis/agent_dossier_export.py

@@ -0,0 +1,110 @@
+from os import PathLike
+from pathlib import Path
+from typing import Dict, List, TypeAlias
+import csv
+import json
+
+from ilc_core.analysis.agent_profiles import AgentProfile
+
+ScalarValue: TypeAlias = str | int | float | bool | None
+AgentDossierRow: TypeAlias = Dict[str, ScalarValue]
+AgentDossierRows: TypeAlias = List[AgentDossierRow]
+
+
+def flatten_profile_for_csv(profile: AgentProfile) -> AgentDossierRow:
+    """
+    Flatten an AgentProfile into a 1-level dict suitable for CSV export.
+
+    Strategy:
+      - Use profile.as_dict() as the base.
+      - Keep simple scalar fields (agent_id, econ_*, claim_*, influence_*, etc.).
+      - For nested dicts (competency, stress_response, light_cone), extract
+        a small number of top-level summary scalars, and also include a
+        *_json column with the full nested data as JSON.
+    """
+    base = profile.as_dict()
+    row: AgentDossierRow = {}
+
+    # Always include agent_id
+    row["agent_id"] = base.get("agent_id")
+
+    # Pass through flat econ/claim/influence keys
+    for k, v in base.items():
+        if k == "agent_id":
+            continue
+        if k in ("competency", "stress_response", "light_cone"):
+            continue
+        # Only include scalars; skip any unexpected nested structures
+        if not isinstance(v, (dict, list)):
+            row[k] = v
+
+    # Competency summary
+    comp = base.get("competency") or {}
+    if comp:
+        global_c = comp.get("global") or {}
+        row["competency_total_tasks"] = global_c.get("total_tasks", 0)
+        row["competency_avg_success_rate"] = global_c.get("avg_success_rate", 0.0)
+        row["competency_json"] = json.dumps(comp)
+
+    # Stress-response summary
+    stress = base.get("stress_response") or {}
+    if stress:
+        # Expect shape like {"by_stress_bucket": {...}, "preference": "..."} for example.
+        row["stress_preference"] = stress.get("preference", "")
+        row["stress_response_json"] = json.dumps(stress)
+
+    # Light-cone summary
+    lc = base.get("light_cone") or {}
+    if lc:
+        row["light_cone_score"] = lc.get("light_cone_score", 0.0)
+        row["light_cone_reach"] = lc.get("reach_score", 0.0)
+        row["light_cone_horizon"] = lc.get("horizon_score", 0.0)
+        row["light_cone_domain_span"] = lc.get("domain_span", 0)
+        row["light_cone_json"] = json.dumps(lc)
+
+    return row
+
+def export_agent_dossiers_to_csv(
+    profiles: Dict[str, AgentProfile],
+    path: PathLike,
+) -> None:
+    """
+    Export all AgentProfiles to a CSV file.
+
+    - Unions all keys across flattened rows to form the header.
+    - Writes one row per agent.
+    """
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+    rows: AgentDossierRows = [flatten_profile_for_csv(pf) for pf in profiles.values()]
+
+    # Handle empty gracefully
+    if not rows:
+        fieldnames = ["agent_id"]
+    else:
+        # Union of all keys
+        keys = set()
+        for r in rows:
+            keys.update(r.keys())
+        fieldnames = sorted(keys)
+
+    with p.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for r in rows:
+            writer.writerow(r)
+
+def export_agent_dossiers_to_json(
+    profiles: Dict[str, AgentProfile],
+    path: PathLike,
+) -> None:
+    """
+    Export all AgentProfiles to a JSON file as a list of flattened rows.
+    """
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+    rows = [flatten_profile_for_csv(pf) for pf in profiles.values()]
+    with p.open("w", encoding="utf-8") as f:
+        json.dump(rows, f, indent=2)

ilc_core/analysis/agent_profiles.py

@@ -0,0 +1,214 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, TypedDict, TypeAlias
+from ilc_core.analysis.claim_scores import ClaimInfluenceRow
+from ilc_core.analysis.competency_kpis import AgentCompetencySummaryMap
+from ilc_core.analysis.light_cone_kpis import AgentLightConeRow
+from os import PathLike
+
+from ilc_core.analysis.econ_kpis import (
+    load_tasks_csv,
+    load_epochs_csv,
+    load_claims_csv,
+    compute_agent_econ_kpis,
+    compute_claim_kpis,
+)
+
+
+class AgentInfluenceRow(TypedDict):
+    total_influence: float
+    num_influenced_claims: float
+    total_net_support: float
+    avg_influence: float
+
+
+AgentInfluenceMap: TypeAlias = Dict[str, AgentInfluenceRow]
+AgentLightConeMap: TypeAlias = Dict[str, AgentLightConeRow]
+ProfileNestedMap: TypeAlias = Dict[str, object]
+ProfileValue: TypeAlias = str | int | float | bool | None | ProfileNestedMap
+AgentProfileDict: TypeAlias = Dict[str, ProfileValue]
+
+@dataclass
+class AgentProfile:
+    agent_id: str
+    node_id: Optional[str] = None
+
+    # Econ KPIs (from compute_basic_kpis)
+    econ: Dict[str, float] = field(default_factory=dict)
+
+    # Claim KPIs (from compute_claim_kpis)
+    claims: Dict[str, float] = field(default_factory=dict)
+
+    # Influence KPIs (from compute_agent_influence_kpis)
+    influence: Dict[str, float] = field(default_factory=dict)
+
+    # Competency (from attach_competency_to_profiles)
+    competency: ProfileNestedMap = field(default_factory=dict)
+
+    # Stress response patterns (from stress_response_kpis)
+    stress_response: ProfileNestedMap = field(default_factory=dict)
+
+    # Light Cone KPIs (from light_cone_kpis)
+    light_cone: ProfileNestedMap = field(default_factory=dict)
+
+    def as_dict(self) -> AgentProfileDict:
+        """
+        Flatten into a single dict for printing/JSON export.
+        Namespaces econ_* and claim_* keys to avoid collisions.
+        """
+        data: AgentProfileDict = {"agent_id": self.agent_id}
+        if self.node_id is not None:
+            data["node_id"] = self.node_id
+
+        for k, v in self.econ.items():
+            data[f"econ_{k}"] = v
+        for k, v in self.claims.items():
+            data[f"claim_{k}"] = v
+        for k, v in self.influence.items():
+            data[f"influence_{k}"] = v
+        if self.competency:
+            data["competency"] = self.competency
+        if self.stress_response:
+            data["stress_response"] = self.stress_response
+        if self.light_cone:
+            data["light_cone"] = self.light_cone
+        return data
+
+def build_agent_profiles(
+    tasks_csv_path: PathLike,
+    epochs_csv_path: PathLike,
+    claims_csv_path: PathLike,
+) -> Dict[str, AgentProfile]:
+    """
+    Load CSVs, compute econ + claim KPIs, and join them into AgentProfile objects.
+
+    Returns:
+        {agent_id: AgentProfile}
+    """
+    tasks = load_tasks_csv(tasks_csv_path)
+    epochs = load_epochs_csv(epochs_csv_path)
+    claims = load_claims_csv(claims_csv_path)
+
+    econ_kpis = compute_agent_econ_kpis(tasks)
+    claim_kpis = compute_claim_kpis(claims)
+
+    profiles: Dict[str, AgentProfile] = {}
+
+    # Seed profiles from econ
+    for agent_id, econ_stats in econ_kpis.items():
+        profiles.setdefault(agent_id, AgentProfile(agent_id=agent_id)).econ = dict(econ_stats)
+
+    # Merge claim stats
+    for agent_id, claim_stats in claim_kpis.items():
+        profile = profiles.setdefault(agent_id, AgentProfile(agent_id=agent_id))
+        profile.claims = dict(claim_stats)
+
+    return profiles
+
+
+def attach_competency_to_profiles(
+    profiles: Dict[str, AgentProfile],
+    competency_summary: AgentCompetencySummaryMap,
+) -> Dict[str, AgentProfile]:
+    """
+    Attach competency summaries to existing AgentProfile objects.
+    If an agent_id in competency_summary is not present in profiles,
+    create a new profile shell for it.
+    """
+    for agent_id, comp in competency_summary.items():
+        profile = profiles.get(agent_id)
+        if profile is None:
+            profile = AgentProfile(agent_id=agent_id)
+            profiles[agent_id] = profile
+        profile.competency = comp
+    return profiles
+
+def compute_agent_influence_kpis(
+    claim_influence_rows: List[ClaimInfluenceRow],
+    claims_csv_path: PathLike,
+) -> AgentInfluenceMap:
+    """
+    Aggregate claim influence metrics per agent.
+
+    Uses claims.csv to map claim_id -> agent_id, then aggregates:
+
+        total_influence
+        avg_influence
+        num_influenced_claims
+        total_net_support
+
+    Returns:
+        {agent_id: {metric_name: value}}
+    """
+    claim_rows = load_claims_csv(claims_csv_path)
+    claim_to_agent: Dict[str, str] = {}
+    for row in claim_rows:
+        cid = row.get("id")
+        aid = row.get("agent_id") or "unknown"
+        if cid:
+            claim_to_agent[cid] = aid
+
+    per_agent: AgentInfluenceMap = {}
+
+    for row in claim_influence_rows:
+        claim_id = row.claim_id
+        agent_id = claim_to_agent.get(claim_id, "unknown")
+
+        stats = per_agent.setdefault(
+            agent_id,
+            {
+                "total_influence": 0.0,
+                "num_influenced_claims": 0.0,
+                "total_net_support": 0.0,
+            },
+        )
+
+        stats["total_influence"] += row.influence_score
+        stats["num_influenced_claims"] += 1.0
+        stats["total_net_support"] += float(row.net_support)
+
+    # Compute derived metrics like avg_influence
+    for stats in per_agent.values():
+        n = stats["num_influenced_claims"]
+        stats["avg_influence"] = stats["total_influence"] / n if n > 0 else 0.0
+
+    return per_agent
+
+def attach_influence_to_profiles(
+    profiles: Dict[str, AgentProfile],
+    claim_influence_rows: List[ClaimInfluenceRow],
+    claims_csv_path: PathLike,
+) -> None:
+    """
+    Compute per-agent influence KPIs and merge them into existing profiles in-place.
+    """
+    influence_kpis = compute_agent_influence_kpis(
+        claim_influence_rows,
+        claims_csv_path,
+    )
+
+    for agent_id, stats in influence_kpis.items():
+        profile = profiles.setdefault(agent_id, AgentProfile(agent_id=agent_id))
+        profile.influence = dict(stats)
+
+def attach_light_cone_to_profiles(
+    profiles: Dict[str, AgentProfile],
+    light_cone_rows: AgentLightConeMap,
+) -> Dict[str, AgentProfile]:
+    """
+    Attach light-cone metrics to existing AgentProfile objects.
+    If an agent_id appears only in light_cone_rows, create a shell profile.
+    """
+    # Note: light_cone_rows is expected to be Dict[str, AgentLightConeRow]
+    # We iterate and access attributes.
+    for agent_id, row in light_cone_rows.items():
+        profile = profiles.get(agent_id)
+        if profile is None:
+            profile = AgentProfile(agent_id=agent_id)
+            profiles[agent_id] = profile
+        profile.light_cone = {
+            "reach_score": row.reach_score,
+            "horizon_score": row.horizon_score,
+            "domain_span": row.domain_span,
+            "light_cone_score": row.light_cone_score,
+        }
+    return profiles