loopx 0.4.8__py3-none-any.whl

loopx/control_plane/status/agent_lane_projection.py

@@ -0,0 +1,375 @@
+"""Agent-lane status projection inside the `status` bounded context."""
+
+from __future__ import annotations
+
+from typing import Any
+
+AGENT_LANE_STATUS_PAYLOAD_COMPACTION_SCHEMA_VERSION = (
+    "agent_lane_status_payload_compaction_v0"
+)
+AGENT_LANE_STATUS_FRONTIER_COMPACTION_SCHEMA_VERSION = (
+    "agent_lane_goal_frontier_compaction_v0"
+)
+AGENT_LANE_STATUS_HISTORY_COMPACTION_SCHEMA_VERSION = (
+    "agent_lane_run_history_compaction_v0"
+)
+AGENT_LANE_STATUS_MANAGEMENT_COMPACTION_SCHEMA_VERSION = (
+    "agent_lane_management_compaction_v0"
+)
+AGENT_LANE_STATUS_GOAL_CHANNEL_COMPACTION_SCHEMA_VERSION = (
+    "agent_lane_goal_channel_compaction_v0"
+)
+
+_PROJECT_ASSET_CANONICAL_FIELDS = (
+    "active_state_next_action",
+    "agent_interaction_summary",
+    "agent_lane_frontier_hint",
+    "agent_lane_next_action",
+    "agent_lane_recommendation",
+    "agent_member",
+    "agent_reward_memory",
+    "autonomous_replan_ack",
+    "autonomous_replan_obligation",
+    "completed_todo_archive_warning",
+    "control_plane",
+    "goal_frontier_projection",
+    "latest_run_recommended_action",
+    "latest_run_recommended_action_source",
+    "next_action_projection_warning",
+    "stale_latest_run_warning",
+)
+
+
+def _as_dict(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _compact_run(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    compact = {
+        key: value[key]
+        for key in (
+            "goal_id",
+            "agent_id",
+            "classification",
+            "generated_at",
+            "lifecycle_phase",
+            "lifecycle_flags",
+        )
+        if value.get(key) is not None
+    }
+    recommendation = str(value.get("recommended_action") or "").strip()
+    if recommendation:
+        compact["recommended_action"] = (
+            recommendation
+            if len(recommendation) <= 240
+            else recommendation[:237].rstrip() + "..."
+        )
+    return compact or None
+
+
+def _agent_semantic_goal(value: Any, *, agent_id: str) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    semantic_history = value.get("semantic_history")
+    if not isinstance(semantic_history, dict):
+        return None
+    contexts = semantic_history.get("agents")
+    current_context = (
+        next(
+            (
+                context
+                for context in contexts
+                if isinstance(context, dict)
+                and str(context.get("agent_id") or "").strip() == agent_id
+            ),
+            None,
+        )
+        if isinstance(contexts, list)
+        else None
+    )
+    owner_correction = semantic_history.get("latest_owner_correction_run")
+    if not isinstance(current_context, dict) and not isinstance(
+        owner_correction,
+        dict,
+    ):
+        return None
+    compact_history: dict[str, Any] = {
+        "schema_version": semantic_history.get("schema_version"),
+        "agents": [current_context] if isinstance(current_context, dict) else [],
+    }
+    if isinstance(owner_correction, dict):
+        compact_history["latest_owner_correction_run"] = owner_correction
+    return {
+        "id": value.get("id"),
+        "semantic_history": compact_history,
+    }
+
+
+def _compact_run_history(payload: dict[str, object], *, agent_id: str) -> bool:
+    history = payload.get("run_history")
+    if not isinstance(history, dict):
+        return False
+    recent_runs = history.get("recent_runs")
+    visible_runs = recent_runs if isinstance(recent_runs, list) else []
+    agent_runs = [
+        run
+        for run in visible_runs
+        if isinstance(run, dict) and str(run.get("agent_id") or "").strip() == agent_id
+    ]
+    goals = history.get("goals")
+    semantic_goals = [
+        compact_goal
+        for compact_goal in (
+            _agent_semantic_goal(goal, agent_id=agent_id)
+            for goal in (goals if isinstance(goals, list) else [])
+        )
+        if compact_goal
+    ]
+    compact = {
+        key: history[key]
+        for key in ("available", "run_count", "goal_count")
+        if history.get(key) is not None
+    }
+    latest_agent_run = _compact_run(agent_runs[0]) if agent_runs else None
+    if latest_agent_run:
+        compact["latest_agent_run"] = latest_agent_run
+    if semantic_goals:
+        compact["goals"] = semantic_goals
+    compact["payload_compaction"] = {
+        "schema_version": AGENT_LANE_STATUS_HISTORY_COMPACTION_SCHEMA_VERSION,
+        "agent_id": agent_id,
+        "visible_agent_run_count": len(agent_runs),
+        "omitted_visible_run_count": max(
+            0,
+            len(visible_runs) - int(latest_agent_run is not None),
+        ),
+        "visible_semantic_goal_count": len(semantic_goals),
+        "full_detail_cold_path": "status without --agent-id or history",
+    }
+    payload["run_history"] = compact
+    return True
+
+
+def _compact_agent_management(payload: dict[str, object], *, agent_id: str) -> bool:
+    projection = payload.get("agent_management_projection")
+    if not isinstance(projection, dict):
+        return False
+    agents = projection.get("agents")
+    visible_agents = agents if isinstance(agents, list) else []
+    current_agents = [
+        agent
+        for agent in visible_agents
+        if isinstance(agent, dict)
+        and str(agent.get("agent_id") or "").strip() == agent_id
+    ]
+    compact = {
+        key: projection[key]
+        for key in (
+            "schema_version",
+            "generated_at",
+            "goal_id",
+            "mode",
+            "source_summary",
+            "truth_contract",
+        )
+        if projection.get(key) is not None
+    }
+    compact["agents"] = current_agents[:1]
+    compact["payload_compaction"] = {
+        "schema_version": AGENT_LANE_STATUS_MANAGEMENT_COMPACTION_SCHEMA_VERSION,
+        "agent_id": agent_id,
+        "visible_agent_count": len(visible_agents),
+        "omitted_other_agent_count": max(0, len(visible_agents) - len(current_agents)),
+        "full_detail_cold_path": "status without --agent-id",
+    }
+    payload["agent_management_projection"] = compact
+    return True
+
+
+def _compact_vision_audit(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    compact = {
+        key: value[key]
+        for key in (
+            "schema_version",
+            "agent_id",
+            "required",
+            "decision",
+            "trigger_count",
+            "trigger_kinds",
+            "selected_todo_is_goal_completion",
+            "closeout_allowed_without_evidence",
+            "recommended_action",
+        )
+        if value.get(key) is not None
+    }
+    judge = value.get("vision_gap_judge")
+    if isinstance(judge, dict):
+        compact["vision_gap_judge"] = {
+            key: judge[key]
+            for key in (
+                "schema_version",
+                "goal_id",
+                "agent_id",
+                "done",
+                "decision",
+                "reason",
+            )
+            if judge.get(key) is not None
+        }
+    for key in (
+        "acceptance_requirements",
+        "authoritative_evidence_kinds",
+        "required_before_closeout",
+    ):
+        items = value.get(key)
+        if isinstance(items, list):
+            compact[f"{key}_count"] = len(items)
+    return compact
+
+
+def _compact_goal_frontier(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    compact = {
+        key: value[key]
+        for key in (
+            "schema_version",
+            "goal_id",
+            "agent_id",
+            "source",
+            "replan_required",
+            "remaining_advancement_frontier",
+            "deferred_successors",
+            "monitor_only_lanes",
+            "normalized_progress",
+            "vision_wait_state",
+            "autonomy_blockers",
+        )
+        if value.get(key) is not None
+    }
+    acceptance_gaps = value.get("acceptance_gaps")
+    if isinstance(acceptance_gaps, list):
+        compact["acceptance_gap_count"] = len(acceptance_gaps)
+        compact["acceptance_gaps"] = [
+            {
+                key: gap[key]
+                for key in (
+                    "kind",
+                    "state",
+                    "source",
+                    "agent_id",
+                    "replan_trigger_source",
+                )
+                if gap.get(key) is not None
+            }
+            for gap in acceptance_gaps[:1]
+            if isinstance(gap, dict)
+        ]
+    vision_audit = _compact_vision_audit(value.get("vision_continuation_audit"))
+    if vision_audit:
+        compact["vision_continuation_audit"] = vision_audit
+    compact["payload_compaction"] = {
+        "schema_version": AGENT_LANE_STATUS_FRONTIER_COMPACTION_SCHEMA_VERSION,
+        "full_detail_cold_path": "status without --agent-id or quota should-run",
+    }
+    return compact
+
+
+def _compact_goal_channel(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    omitted_fields = (
+        "agent_todos",
+        "user_todos",
+        "recent_events",
+        "active_leases",
+        "source_warnings",
+    )
+    compact = {key: child for key, child in value.items() if key not in omitted_fields}
+    compact["payload_compaction"] = {
+        "schema_version": AGENT_LANE_STATUS_GOAL_CHANNEL_COMPACTION_SCHEMA_VERSION,
+        **{
+            f"omitted_{key[:-1] if key.endswith('s') else key}_count": len(
+                value.get(key) or []
+            )
+            for key in omitted_fields
+        },
+        "canonical_todo_path": "attention_queue.items[].{agent_todos,user_todos}",
+        "full_detail_cold_path": "status without --agent-id",
+    }
+    return compact
+
+
+def _compact_attention_item(item: dict[str, Any]) -> tuple[int, bool]:
+    project_asset = _as_dict(item.get("project_asset"))
+    removed_duplicates = 0
+    if project_asset:
+        item_frontier = item.get("goal_frontier_projection")
+        asset_frontier = project_asset.get("goal_frontier_projection")
+        if item_frontier is not None and item_frontier == asset_frontier:
+            item.pop("goal_frontier_projection")
+            removed_duplicates += 1
+        frontier = _compact_goal_frontier(asset_frontier or item_frontier)
+        if frontier:
+            project_asset["goal_frontier_projection"] = frontier
+        next_action = project_asset.get("next_action")
+        for key in ("active_state_next_action", "latest_run_recommended_action"):
+            if next_action and project_asset.get(key) == next_action:
+                if item.get(key) == next_action:
+                    item.pop(key)
+                    removed_duplicates += 1
+                project_asset.pop(key)
+        for key in _PROJECT_ASSET_CANONICAL_FIELDS:
+            if key in item and key in project_asset and item[key] == project_asset[key]:
+                item.pop(key)
+                removed_duplicates += 1
+    goal_channel = _compact_goal_channel(item.get("goal_channel_projection"))
+    if goal_channel:
+        item["goal_channel_projection"] = goal_channel
+    return removed_duplicates, bool(goal_channel)
+
+
+def compact_agent_lane_status_payload_for_display(
+    payload: dict[str, object],
+    *,
+    agent_id: str,
+) -> None:
+    safe_agent_id = str(agent_id or "").strip()
+    if not safe_agent_id:
+        return
+    queue = payload.get("attention_queue")
+    items = queue.get("items") if isinstance(queue, dict) else None
+    compacted_items = 0
+    removed_duplicates = 0
+    compacted_goal_channels = 0
+    if isinstance(items, list):
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            removed, channel_compacted = _compact_attention_item(item)
+            removed_duplicates += removed
+            compacted_goal_channels += int(channel_compacted)
+            compacted_items += 1
+    history_compacted = _compact_run_history(payload, agent_id=safe_agent_id)
+    management_compacted = _compact_agent_management(
+        payload,
+        agent_id=safe_agent_id,
+    )
+    if compacted_items or history_compacted or management_compacted:
+        payload["agent_lane_status_payload_compaction"] = {
+            "schema_version": AGENT_LANE_STATUS_PAYLOAD_COMPACTION_SCHEMA_VERSION,
+            "agent_id": safe_agent_id,
+            "compacted_attention_item_count": compacted_items,
+            "removed_project_asset_duplicate_count": removed_duplicates,
+            "compacted_goal_channel_count": compacted_goal_channels,
+            "run_history_compacted": history_compacted,
+            "agent_management_compacted": management_compacted,
+            "reason": (
+                "status --agent-id keeps current-agent control semantics hot "
+                "and moves whole-goal diagnostics to explicit cold paths"
+            ),
+        }

loopx/control_plane/status/attention_projection.py

@@ -0,0 +1,74 @@
+"""Status attention projections inside the `status` bounded context."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..todos.contract import (
+    TODO_TASK_CLASS_ADVANCEMENT,
+    TODO_TASK_CLASS_MONITOR,
+)
+from ..todos.todo_summary import (
+    normalize_todo_text,
+    open_todo_items,
+    todo_item_is_actionable_open,
+)
+from ..work_items.attention_queue import (
+    build_attention_queue_projection as _build_attention_queue_projection,
+)
+from ..work_items.autonomous_candidates import (
+    MAX_AUTONOMOUS_TODO_CANDIDATES,
+    autonomous_backlog_candidates as _autonomous_backlog_candidates,
+    autonomous_monitor_candidates as _autonomous_monitor_candidates,
+)
+
+
+MONITOR_SIGNAL_WAITING_ON = "monitor_signal"
+MAX_AUTONOMOUS_BACKLOG_CANDIDATES = MAX_AUTONOMOUS_TODO_CANDIDATES
+
+
+def autonomous_backlog_candidates(
+    items: list[dict[str, Any]],
+    *,
+    limit: int = MAX_AUTONOMOUS_BACKLOG_CANDIDATES,
+) -> dict[str, Any] | None:
+    return _autonomous_backlog_candidates(
+        items,
+        open_todo_items=open_todo_items,
+        todo_item_is_actionable_open=todo_item_is_actionable_open,
+        normalize_todo_text=normalize_todo_text,
+        advancement_task_class=TODO_TASK_CLASS_ADVANCEMENT,
+        limit=limit,
+    )
+
+
+def autonomous_monitor_candidates(
+    items: list[dict[str, Any]],
+    *,
+    limit: int = MAX_AUTONOMOUS_BACKLOG_CANDIDATES,
+) -> dict[str, Any] | None:
+    return _autonomous_monitor_candidates(
+        items,
+        open_todo_items=open_todo_items,
+        todo_item_is_actionable_open=todo_item_is_actionable_open,
+        normalize_todo_text=normalize_todo_text,
+        monitor_task_class=TODO_TASK_CLASS_MONITOR,
+        monitor_signal_waiting_on=MONITOR_SIGNAL_WAITING_ON,
+        limit=limit,
+    )
+
+
+def build_attention_queue_projection(
+    *,
+    items: list[dict[str, Any]],
+    goal_id_filter: str | None,
+    autonomous_backlog_candidates: dict[str, Any] | None,
+    autonomous_monitor_candidates: dict[str, Any] | None,
+) -> dict[str, Any]:
+    return _build_attention_queue_projection(
+        items=items,
+        goal_id_filter=goal_id_filter,
+        autonomous_backlog_candidates=autonomous_backlog_candidates,
+        autonomous_monitor_candidates=autonomous_monitor_candidates,
+        monitor_signal_waiting_on=MONITOR_SIGNAL_WAITING_ON,
+    )

loopx/control_plane/status/autonomous_replan_projection.py

@@ -0,0 +1,103 @@
+"""Autonomous replan status projections inside the `status` bounded context."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..runtime.public_safety import public_safe_compact_text
+from ..work_items.autonomous_replan_ack import (
+    AUTONOMOUS_REPLAN_ACK_MATERIAL_RUN_WINDOW,
+    autonomous_replan_ack_recorded,
+    latest_autonomous_replan_ack_for_projection as _latest_autonomous_replan_ack_for_projection,
+)
+from ..work_items.autonomous_replan_obligation import (
+    AUTONOMOUS_REPLAN_STALL_THRESHOLD,
+    autonomous_replan_obligation_from_runs as _autonomous_replan_obligation_from_runs,
+    autonomous_replan_periodic_review_from_runs as _autonomous_replan_periodic_review_from_runs,
+    build_autonomous_replan_obligation as _build_autonomous_replan_obligation,
+    run_history_monitor_wait_already_acknowledged as _run_history_monitor_wait_already_acknowledged,
+)
+
+
+DEAD_MONITOR_REPEAT_THRESHOLD = 6
+DEAD_MONITOR_REPEAT_SCHEMA_VERSION = "dead_monitor_repeat_v0"
+AUTONOMOUS_REPLAN_SCHEMA_VERSION = "autonomous_replan_obligation_v0"
+AUTONOMOUS_REPLAN_PERIODIC_RUN_THRESHOLD = AUTONOMOUS_REPLAN_ACK_MATERIAL_RUN_WINDOW
+AUTONOMOUS_RUN_HISTORY_NEUTRAL_CLASSIFICATIONS = {
+    "quota_slot_spent",
+    "quota_slot_voided",
+    "delivery_completion_spend_accounted_v0",
+}
+
+
+def build_autonomous_replan_obligation(
+    evidence: list[dict[str, Any]],
+    *,
+    agent_todos: dict[str, Any] | None,
+) -> dict[str, Any] | None:
+    return _build_autonomous_replan_obligation(
+        evidence,
+        agent_todos=agent_todos,
+        public_safe_compact_text=public_safe_compact_text,
+        autonomous_replan_schema_version=AUTONOMOUS_REPLAN_SCHEMA_VERSION,
+        autonomous_replan_stall_threshold=AUTONOMOUS_REPLAN_STALL_THRESHOLD,
+        dead_monitor_repeat_threshold=DEAD_MONITOR_REPEAT_THRESHOLD,
+        dead_monitor_repeat_schema_version=DEAD_MONITOR_REPEAT_SCHEMA_VERSION,
+    )
+
+
+def run_history_monitor_wait_already_acknowledged(
+    latest_runs: list[dict[str, Any]] | None,
+    *,
+    signal_count: int,
+) -> bool:
+    return _run_history_monitor_wait_already_acknowledged(
+        latest_runs,
+        signal_count=signal_count,
+        autonomous_replan_ack_recorded=autonomous_replan_ack_recorded,
+        neutral_classifications=AUTONOMOUS_RUN_HISTORY_NEUTRAL_CLASSIFICATIONS,
+    )
+
+
+def latest_autonomous_replan_ack_for_projection(
+    latest_runs: list[dict[str, Any]] | None,
+) -> dict[str, Any] | None:
+    return _latest_autonomous_replan_ack_for_projection(
+        latest_runs,
+        neutral_classifications=AUTONOMOUS_RUN_HISTORY_NEUTRAL_CLASSIFICATIONS,
+    )
+
+
+def autonomous_replan_periodic_review_from_runs(
+    latest_runs: list[dict[str, Any]] | None,
+    *,
+    agent_todos: dict[str, Any] | None,
+) -> dict[str, Any] | None:
+    return _autonomous_replan_periodic_review_from_runs(
+        latest_runs,
+        agent_todos=agent_todos,
+        autonomous_replan_ack_recorded=autonomous_replan_ack_recorded,
+        neutral_classifications=AUTONOMOUS_RUN_HISTORY_NEUTRAL_CLASSIFICATIONS,
+        periodic_run_threshold=AUTONOMOUS_REPLAN_PERIODIC_RUN_THRESHOLD,
+        build_autonomous_replan_obligation=build_autonomous_replan_obligation,
+    )
+
+
+def autonomous_replan_obligation_from_runs(
+    latest_runs: list[dict[str, Any]] | None,
+    *,
+    agent_todos: dict[str, Any] | None,
+    agent_id: str | None = None,
+) -> dict[str, Any] | None:
+    return _autonomous_replan_obligation_from_runs(
+        latest_runs,
+        agent_todos=agent_todos,
+        agent_id=agent_id,
+        autonomous_replan_ack_recorded=autonomous_replan_ack_recorded,
+        neutral_classifications=AUTONOMOUS_RUN_HISTORY_NEUTRAL_CLASSIFICATIONS,
+        build_autonomous_replan_obligation=build_autonomous_replan_obligation,
+        autonomous_replan_stall_threshold=AUTONOMOUS_REPLAN_STALL_THRESHOLD,
+        dead_monitor_repeat_threshold=DEAD_MONITOR_REPEAT_THRESHOLD,
+        dead_monitor_repeat_schema_version=DEAD_MONITOR_REPEAT_SCHEMA_VERSION,
+        periodic_run_threshold=AUTONOMOUS_REPLAN_PERIODIC_RUN_THRESHOLD,
+    )

loopx/control_plane/status/collection.py

@@ -0,0 +1,140 @@
+"""Status collection assembly inside the `status` bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from ..goals.contract_health import project_contract_health_for_goal
+from ..runtime.runtime_projection_route import (
+    collect_runtime_projection_route_diagnostics,
+)
+
+
+StatusCallback = Callable[..., Any]
+
+
+@dataclass(frozen=True)
+class StatusCollectionContext:
+    load_registry: StatusCallback
+    resolve_runtime_root: StatusCallback
+    collect_global_registry_health: StatusCallback
+    collect_history: StatusCallback
+    check_contract: StatusCallback
+    build_attention_queue: StatusCallback
+    build_runtime_summaries: StatusCallback
+    build_promotion_gate: StatusCallback
+    build_status_contract: StatusCallback
+    build_contract_health_projection: StatusCallback
+    build_agent_management_projection: StatusCallback
+    status_control_plane_context_limit: int
+    max_todo_index_items: int
+
+
+def collect_status(
+    *,
+    registry_path: Path,
+    runtime_root_override: str | None,
+    scan_roots: list[Path],
+    limit: int,
+    context: StatusCollectionContext,
+    include_task_graph: bool = False,
+    goal_id: str | None = None,
+    available_capabilities: Any = None,
+) -> dict[str, Any]:
+    display_limit = max(0, limit)
+    control_plane_limit = max(display_limit, context.status_control_plane_context_limit)
+    goal_filter = str(goal_id or "").strip() or None
+    registry = context.load_registry(registry_path)
+    runtime_root = context.resolve_runtime_root(
+        registry,
+        runtime_root_override,
+        registry_path=registry_path,
+    )
+    global_registry = context.collect_global_registry_health(
+        registry_path=registry_path,
+        runtime_root=runtime_root,
+        current_registry=registry,
+    )
+    include_runtime_goals = bool(global_registry.get("current_registry_is_global"))
+    history = context.collect_history(
+        registry_path=registry_path,
+        runtime_root=runtime_root,
+        goal_id=goal_filter,
+        limit=control_plane_limit,
+        include_runtime_goals=include_runtime_goals,
+    )
+    contract = context.check_contract(
+        registry_path=registry_path,
+        runtime_root_override=str(runtime_root),
+        scan_roots=scan_roots,
+        limit=limit,
+        goal_id_filter=goal_filter,
+    )
+    contract = project_contract_health_for_goal(contract, goal_id=goal_filter)
+    queue = context.build_attention_queue(
+        contract=contract,
+        history=history,
+        global_registry=global_registry,
+        runtime_root=runtime_root,
+        include_task_graph=include_task_graph,
+        goal_id_filter=goal_filter,
+    )
+    runtime_summaries = context.build_runtime_summaries(
+        history=history,
+        queue=queue,
+        runtime_root=runtime_root,
+        goal_id_filter=goal_filter,
+        display_limit=display_limit,
+        todo_index_limit=max(context.max_todo_index_items, display_limit),
+    )
+    promotion_gate = context.build_promotion_gate(
+        registry_path=registry_path,
+        runtime_root_override=str(runtime_root),
+    )
+    runtime_projection_routes = collect_runtime_projection_route_diagnostics(
+        registry_path=registry_path,
+        runtime_root=runtime_root,
+        goal_id=goal_filter,
+    )
+    runtime_projection_route_health = {
+        "healthy": (
+            bool(runtime_projection_routes.get("healthy"))
+            if runtime_projection_routes.get("available")
+            else None
+        )
+    }
+    contract_projection = {
+        "ok": contract.get("ok"),
+        "summary": contract.get("summary"),
+        "errors": contract.get("errors") or [],
+        "warnings": contract.get("warnings") or [],
+        "checks": contract.get("checks") or [],
+    }
+    for key in ("error_diagnostics", "global_errors", "goal_errors"):
+        if contract.get(key):
+            contract_projection[key] = contract[key]
+    payload = {
+        "ok": bool(contract.get("ok")) and bool(global_registry.get("ok", True)),
+        "registry": str(registry_path),
+        "runtime_root": str(runtime_root),
+        "goal_count": history.get("goal_count"),
+        "run_count": history.get("run_count"),
+        "status_contract": context.build_status_contract(),
+        "goal_filter": goal_filter,
+        **context.build_contract_health_projection(contract),
+        "contract": contract_projection,
+        "global_registry": global_registry,
+        "attention_queue": queue,
+        **runtime_summaries,
+        "promotion_gate": promotion_gate,
+    }
+    payload["runtime_projection_routes"] = runtime_projection_route_health
+    agent_management_projection = context.build_agent_management_projection(
+        payload,
+        available_capabilities=available_capabilities,
+    )
+    if agent_management_projection.get("agents"):
+        payload["agent_management_projection"] = agent_management_projection
+    return payload