loopx 0.4.8__py3-none-any.whl

loopx/control_plane/work_items/attention_fields.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Optional
+
+
+CompactProjection = Callable[[Any], Optional[dict[str, Any]]]
+NormalizeOperatorQuestion = Callable[..., str]
+
+
+def readiness_attention_fields(
+    run: dict[str, Any] | None,
+    *,
+    compact_controller_readiness: CompactProjection,
+) -> dict[str, Any]:
+    if not isinstance(run, dict):
+        return {}
+    readiness = compact_controller_readiness(run.get("controller_readiness"))
+    if not readiness:
+        return {}
+    fields: dict[str, Any] = {}
+    if readiness.get("classification"):
+        fields["controller_stage"] = readiness.get("classification")
+    missing = readiness.get("missing_gates")
+    if isinstance(missing, list):
+        public_missing = [str(gate) for gate in missing if gate]
+        if public_missing:
+            fields["missing_gates"] = public_missing
+    if readiness.get("next_handoff_condition"):
+        fields["next_handoff_condition"] = readiness.get("next_handoff_condition")
+    return fields
+
+
+def operator_gate_attention_fields(
+    run: dict[str, Any] | None,
+    *,
+    compact_operator_gate: CompactProjection,
+    normalize_operator_question: NormalizeOperatorQuestion,
+    default_operator_gate: str,
+) -> dict[str, Any]:
+    if not isinstance(run, dict):
+        return {}
+    operator_gate = compact_operator_gate(run.get("operator_gate"))
+    if not operator_gate:
+        return {}
+    fields: dict[str, Any] = {}
+    if operator_gate.get("decision") != "approve" and operator_gate.get("operator_question"):
+        fields["operator_question"] = normalize_operator_question(
+            str(operator_gate.get("operator_question") or ""),
+            goal_id=str(run.get("goal_id") or ""),
+            gate=str(operator_gate.get("gate") or default_operator_gate),
+        )
+    if operator_gate.get("decision") == "approve" and operator_gate.get("agent_command"):
+        fields["agent_command"] = operator_gate.get("agent_command")
+    if operator_gate.get("follow_up"):
+        fields["next_handoff_condition"] = operator_gate.get("follow_up")
+    return fields

loopx/control_plane/work_items/attention_item.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Optional
+
+
+ProjectAssetBuilder = Callable[..., dict[str, Any]]
+DreamingLaneBadgeBuilder = Callable[[Optional[dict[str, Any]]], Optional[dict[str, Any]]]
+
+
+def attention_item(
+    *,
+    goal_id: str,
+    status: str,
+    waiting_on: str,
+    severity: str,
+    recommended_action: str,
+    source: str,
+    build_project_asset: ProjectAssetBuilder,
+    compact_dreaming_lane_badge: DreamingLaneBadgeBuilder,
+    operator_question: str | None = None,
+    agent_command: str | None = None,
+    controller_stage: str | None = None,
+    missing_gates: list[str] | None = None,
+    next_handoff_condition: str | None = None,
+    lifecycle_phase: str | None = None,
+    lifecycle_flags: list[str] | None = None,
+    user_todos: dict[str, Any] | None = None,
+    agent_todos: dict[str, Any] | None = None,
+    todo_state_file: str | None = None,
+    dreaming_proposal: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    project_asset = build_project_asset(
+        status=status,
+        waiting_on=waiting_on,
+        recommended_action=recommended_action,
+        operator_question=operator_question,
+        agent_command=agent_command,
+        missing_gates=missing_gates,
+        next_handoff_condition=next_handoff_condition,
+    )
+    item = {
+        "goal_id": goal_id,
+        "status": status,
+        "waiting_on": waiting_on,
+        "severity": severity,
+        "recommended_action": recommended_action,
+        "project_asset": project_asset,
+        "source": source,
+    }
+    if operator_question:
+        item["operator_question"] = operator_question
+    if agent_command:
+        item["agent_command"] = agent_command
+    if controller_stage:
+        item["controller_stage"] = controller_stage
+    if missing_gates:
+        item["missing_gates"] = missing_gates
+    if next_handoff_condition:
+        item["next_handoff_condition"] = next_handoff_condition
+    if lifecycle_phase:
+        item["lifecycle_phase"] = lifecycle_phase
+    if lifecycle_flags:
+        item["lifecycle_flags"] = lifecycle_flags
+    if user_todos:
+        item["user_todos"] = user_todos
+    if agent_todos:
+        item["agent_todos"] = agent_todos
+    if todo_state_file:
+        item["todo_state_file"] = todo_state_file
+    if dreaming_proposal:
+        dreaming_lane_badge = compact_dreaming_lane_badge(dreaming_proposal)
+        item["dreaming_proposal"] = dreaming_proposal
+        item["project_asset"]["dreaming_proposal"] = dreaming_proposal
+        if dreaming_lane_badge:
+            item["dreaming_lane_badge"] = dreaming_lane_badge
+            item["project_asset"]["dreaming_lane_badge"] = dreaming_lane_badge
+    return item

loopx/control_plane/work_items/attention_queue.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import AbstractSet, Any, Callable, Optional
+
+
+AttentionItemBuilder = Callable[..., dict[str, Any]]
+GlobalRegistryShadowAttacher = Callable[[dict[str, Any], dict[str, Any]], None]
+
+
+@dataclass(frozen=True)
+class AttentionQueueContext:
+    active_state_todo_fields: Callable[..., dict[str, Any]]
+    active_state_todo_attention_item: Callable[..., dict[str, Any] | None]
+    latest_run: Callable[[dict[str, Any]], dict[str, Any] | None]
+    goal_attention: Callable[[dict[str, Any]], dict[str, Any] | None]
+    compact_agent_lane_recommendation: Callable[[dict[str, Any] | None], dict[str, Any] | None]
+    latest_agent_lane_run: Callable[[dict[str, Any]], dict[str, Any] | None]
+    latest_run_recommended_action_for_projection: Callable[..., tuple[str | None, str | None]]
+    compact_autonomous_replan_ack: Callable[[dict[str, Any] | None], dict[str, Any] | None]
+    latest_autonomous_replan_ack_for_projection: Callable[[list[dict[str, Any]] | None], dict[str, Any] | None]
+    compact_control_plane_policy: Callable[[Any], dict[str, Any]]
+    subagent_activity_for_goal: Callable[[dict[str, Any]], dict[str, Any] | None]
+    interface_budget_cadence_for_runs: Callable[[list[dict[str, Any]]], dict[str, Any]]
+    active_state_projection_warning: Callable[[dict[str, Any], dict[str, Any] | None], dict[str, Any] | None]
+    enrich_project_asset: Callable[..., None]
+    project_asset_latest_validation: Callable[[dict[str, Any] | None], dict[str, Any] | None]
+    attach_active_state_project_asset_fields: Callable[..., None]
+    sync_connected_attention_action_from_todos: Callable[[dict[str, Any]], None]
+    quota_status: Callable[..., dict[str, Any]]
+    quota_with_handoff_outcome_floor: Callable[..., dict[str, Any]]
+    normalize_monitor_quiet_attention_display: Callable[[dict[str, Any]], None]
+    build_task_graph_projection: Callable[..., dict[str, Any] | None]
+    attach_goal_channel_projection: Callable[..., None]
+    attach_dependency_blockers: Callable[[list[dict[str, Any]]], None]
+    autonomous_backlog_candidates: Callable[[list[dict[str, Any]]], dict[str, Any] | None]
+    autonomous_monitor_candidates: Callable[[list[dict[str, Any]]], dict[str, Any] | None]
+    attention_item: AttentionItemBuilder
+    attach_global_registry_shadow_finding: GlobalRegistryShadowAttacher
+    next_action_projection_warning: Callable[..., dict[str, Any] | None]
+    autonomous_replan_obligation_from_runs: Callable[..., dict[str, Any] | None]
+    source_registry_shadow_findings: AbstractSet[str]
+    monitor_signal_waiting_on: str
+
+
+def merge_global_registry_findings(
+    *,
+    health_items: list[dict[str, Any]],
+    history_items: list[dict[str, Any]],
+    findings: list[Any],
+    goal_id_filter: Optional[str],
+    source_registry_shadow_findings: AbstractSet[str],
+    attention_item: AttentionItemBuilder,
+    attach_global_registry_shadow_finding: GlobalRegistryShadowAttacher,
+) -> None:
+    live_quota_items_by_goal: dict[str, list[dict[str, Any]]] = {}
+    for item in history_items:
+        if isinstance(item.get("quota"), dict):
+            live_quota_items_by_goal.setdefault(str(item.get("goal_id") or ""), []).append(item)
+
+    for finding in findings:
+        if not isinstance(finding, dict):
+            continue
+        if finding.get("severity") not in {"high", "action"}:
+            continue
+        goal_id = str(finding.get("goal_id") or "global-registry")
+        if goal_id_filter:
+            finding_goal_ids = [
+                str(item)
+                for item in (finding.get("goal_ids") or [])
+                if str(item or "").strip()
+            ]
+            if goal_id != goal_id_filter and goal_id_filter not in finding_goal_ids:
+                continue
+        live_items = live_quota_items_by_goal.get(goal_id, [])
+        if finding.get("kind") in source_registry_shadow_findings and live_items:
+            for item in live_items:
+                attach_global_registry_shadow_finding(item, finding)
+            continue
+        health_items.append(
+            attention_item(
+                goal_id=goal_id,
+                status=str(finding.get("kind") or "global_registry_finding"),
+                waiting_on="codex",
+                severity=str(finding.get("severity") or "action"),
+                recommended_action=str(finding.get("recommended_action") or "inspect global registry health"),
+                source="global_registry",
+            )
+        )
+
+
+def build_attention_queue_projection(
+    *,
+    items: list[dict[str, Any]],
+    goal_id_filter: Optional[str],
+    autonomous_backlog_candidates: Optional[dict[str, Any]],
+    autonomous_monitor_candidates: Optional[dict[str, Any]],
+    monitor_signal_waiting_on: str,
+) -> dict[str, Any]:
+    queue: dict[str, Any] = {
+        "available": True,
+        "item_count": len(items),
+        "needs_user_or_controller": sum(
+            1 for item in items if item["waiting_on"] in {"user_or_controller", "controller"}
+        ),
+        "needs_controller": sum(1 for item in items if item["waiting_on"] == "controller"),
+        "needs_codex": sum(1 for item in items if item["waiting_on"] == "codex"),
+        "watching_external_evidence": sum(1 for item in items if item["waiting_on"] == "external_evidence"),
+        "watching_monitor": sum(1 for item in items if item["waiting_on"] == monitor_signal_waiting_on),
+        "items": items,
+    }
+    if goal_id_filter:
+        queue["goal_filter"] = goal_id_filter
+        queue["goal_filter_applied"] = True
+    if autonomous_backlog_candidates:
+        queue["autonomous_backlog_candidates"] = autonomous_backlog_candidates
+    if autonomous_monitor_candidates:
+        queue["autonomous_monitor_candidates"] = autonomous_monitor_candidates
+    return queue
+
+
+def build_attention_queue(
+    *,
+    contract: dict[str, Any],
+    history: dict[str, Any],
+    global_registry: dict[str, Any],
+    context: AttentionQueueContext,
+    runtime_root: Path | None = None,
+    include_task_graph: bool = False,
+    goal_id_filter: str | None = None,
+) -> dict[str, Any]:
+    health_items: list[dict[str, Any]] = []
+    history_items: list[dict[str, Any]] = []
+    if contract.get("ok") is False:
+        health_items.append(
+            context.attention_item(
+                goal_id="loopx-contract",
+                status="contract_check_failed",
+                waiting_on="codex",
+                severity="high",
+                recommended_action="fix contract errors before advancing goal adapters",
+                source="contract",
+            )
+        )
+
+    for goal in history.get("goals") or []:
+        if not isinstance(goal, dict):
+            continue
+        active_state_fields: dict[str, Any] | None = None
+        active_state_item: dict[str, Any] | None = None
+        current_status_run = context.latest_run(goal)
+        goal_latest_runs = goal.get("latest_runs") if isinstance(goal.get("latest_runs"), list) else []
+        if goal.get("registry_member"):
+            active_state_fields = context.active_state_todo_fields(goal, runtime_root=runtime_root)
+            active_state_item = context.active_state_todo_attention_item(
+                goal,
+                active_state_fields,
+                current_status_run,
+            )
+        if active_state_item and active_state_item.get("waiting_on") in {"controller", "user_or_controller"}:
+            item = active_state_item
+        else:
+            item = context.goal_attention(goal)
+            if not item:
+                item = active_state_item
+        if item:
+            agent_lane_recommendation = context.compact_agent_lane_recommendation(
+                context.latest_agent_lane_run(goal)
+            )
+            active_state_next_action = (
+                active_state_fields.get("active_state_next_action")
+                if isinstance(active_state_fields, dict)
+                else None
+            )
+            latest_run_action, latest_run_action_source = (
+                context.latest_run_recommended_action_for_projection(
+                    current_status_run=current_status_run,
+                    agent_lane_recommendation=agent_lane_recommendation,
+                    active_state_next_action=active_state_next_action,
+                    preferred_agent_id=None,
+                )
+            )
+            if latest_run_action:
+                item["latest_run_recommended_action"] = latest_run_action
+                if latest_run_action_source:
+                    item["latest_run_recommended_action_source"] = latest_run_action_source
+                if isinstance(item.get("project_asset"), dict):
+                    item["project_asset"]["latest_run_recommended_action"] = latest_run_action
+                    if latest_run_action_source:
+                        item["project_asset"][
+                            "latest_run_recommended_action_source"
+                        ] = latest_run_action_source
+            replan_ack = context.compact_autonomous_replan_ack(
+                current_status_run
+            ) or context.latest_autonomous_replan_ack_for_projection(goal_latest_runs)
+            if replan_ack:
+                item["autonomous_replan_ack"] = replan_ack
+                if isinstance(item.get("project_asset"), dict):
+                    item["project_asset"]["autonomous_replan_ack"] = replan_ack
+            control_plane = context.compact_control_plane_policy(goal.get("control_plane"))
+            if control_plane:
+                item["control_plane"] = control_plane
+            if agent_lane_recommendation:
+                item["agent_lane_recommendation"] = agent_lane_recommendation
+            subagent_activity = context.subagent_activity_for_goal(goal)
+            interface_budget_cadence = context.interface_budget_cadence_for_runs(goal_latest_runs)
+            projection_warning = context.active_state_projection_warning(goal, context.latest_run(goal))
+            context.enrich_project_asset(
+                item,
+                latest_validation=context.project_asset_latest_validation(context.latest_run(goal)),
+                latest_runs=goal_latest_runs,
+                execution_profile=(
+                    goal.get("execution_profile")
+                    if isinstance(goal.get("execution_profile"), dict)
+                    else None
+                ),
+                orchestration=(
+                    goal.get("spawn_policy")
+                    if isinstance(goal.get("spawn_policy"), dict)
+                    else None
+                ),
+                subagent_activity=subagent_activity,
+                interface_budget_cadence=interface_budget_cadence,
+            )
+            if control_plane and isinstance(item.get("project_asset"), dict):
+                item["project_asset"]["control_plane"] = control_plane
+            if agent_lane_recommendation and isinstance(item.get("project_asset"), dict):
+                item["project_asset"]["agent_lane_recommendation"] = agent_lane_recommendation
+            if projection_warning:
+                item["stale_latest_run_warning"] = projection_warning
+                if isinstance(item.get("project_asset"), dict):
+                    item["project_asset"]["stale_latest_run_warning"] = projection_warning
+            if goal.get("registry_member"):
+                if active_state_fields is None:
+                    active_state_fields = context.active_state_todo_fields(goal, runtime_root=runtime_root)
+                item.update(active_state_fields)
+                context.sync_connected_attention_action_from_todos(item)
+                context.attach_active_state_project_asset_fields(
+                    item,
+                    latest_runs=goal_latest_runs,
+                    next_action_projection_warning=context.next_action_projection_warning,
+                    autonomous_replan_obligation_from_runs=context.autonomous_replan_obligation_from_runs,
+                )
+                item["quota"] = context.quota_status(
+                    goal,
+                    waiting_on=str(item.get("waiting_on") or ""),
+                    severity=str(item.get("severity") or ""),
+                    lifecycle_phase=item.get("lifecycle_phase"),
+                    lifecycle_flags=item.get("lifecycle_flags"),
+                    status=item.get("status"),
+                )
+                context.enrich_project_asset(
+                    item,
+                    user_todos=item.get("user_todos") if isinstance(item.get("user_todos"), dict) else None,
+                    agent_todos=item.get("agent_todos") if isinstance(item.get("agent_todos"), dict) else None,
+                    quota=item.get("quota") if isinstance(item.get("quota"), dict) else None,
+                    latest_runs=goal_latest_runs,
+                    subagent_activity=subagent_activity,
+                    interface_budget_cadence=interface_budget_cadence,
+                )
+                guarded_quota = context.quota_with_handoff_outcome_floor(
+                    item.get("quota") if isinstance(item.get("quota"), dict) else {},
+                    waiting_on=str(item.get("waiting_on") or ""),
+                    project_asset=item.get("project_asset")
+                    if isinstance(item.get("project_asset"), dict)
+                    else None,
+                    handoff_readiness=item.get("handoff_readiness")
+                    if isinstance(item.get("handoff_readiness"), dict)
+                    else None,
+                )
+                if guarded_quota != item.get("quota"):
+                    item["quota"] = guarded_quota
+                    context.enrich_project_asset(
+                        item,
+                        user_todos=item.get("user_todos") if isinstance(item.get("user_todos"), dict) else None,
+                        agent_todos=item.get("agent_todos") if isinstance(item.get("agent_todos"), dict) else None,
+                        quota=guarded_quota,
+                        latest_runs=goal_latest_runs,
+                        subagent_activity=subagent_activity,
+                        interface_budget_cadence=interface_budget_cadence,
+                    )
+                context.sync_connected_attention_action_from_todos(item)
+                context.normalize_monitor_quiet_attention_display(item)
+            if include_task_graph:
+                task_graph_projection = context.build_task_graph_projection(
+                    item,
+                    goal=goal,
+                    goal_latest_runs=goal_latest_runs,
+                )
+                if task_graph_projection:
+                    item["task_graph_projection"] = task_graph_projection
+            context.attach_goal_channel_projection(
+                item,
+                goal=goal,
+                goal_latest_runs=goal_latest_runs,
+                runtime_root=runtime_root,
+            )
+            history_items.append(item)
+
+    merge_global_registry_findings(
+        health_items=health_items,
+        history_items=history_items,
+        findings=global_registry.get("findings") or [],
+        goal_id_filter=goal_id_filter,
+        source_registry_shadow_findings=context.source_registry_shadow_findings,
+        attention_item=context.attention_item,
+        attach_global_registry_shadow_finding=context.attach_global_registry_shadow_finding,
+    )
+
+    items = [*health_items, *history_items]
+    context.attach_dependency_blockers(items)
+    backlog_candidates = context.autonomous_backlog_candidates(items)
+    monitor_candidates = context.autonomous_monitor_candidates(items)
+
+    return build_attention_queue_projection(
+        items=items,
+        goal_id_filter=goal_id_filter,
+        autonomous_backlog_candidates=backlog_candidates,
+        autonomous_monitor_candidates=monitor_candidates,
+        monitor_signal_waiting_on=context.monitor_signal_waiting_on,
+    )

loopx/control_plane/work_items/attention_routing.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from typing import AbstractSet, Any, Callable, Optional
+
+from ..runtime.session_runtime import session_runtime_projection_attention
+
+
+AttentionItemBuilder = Callable[..., dict[str, Any]]
+AttentionFieldsBuilder = Callable[[Optional[dict[str, Any]]], dict[str, Any]]
+GoalLifecycleFields = Callable[[dict[str, Any], Optional[dict[str, Any]]], dict[str, Any]]
+LatestRun = Callable[[dict[str, Any]], Optional[dict[str, Any]]]
+LegacyRuntimeGoalAttention = Callable[
+    [dict[str, Any], Optional[dict[str, Any]], dict[str, Any]],
+    Optional[dict[str, Any]],
+]
+OperatorQuestionBuilder = Callable[[str, str], str]
+OperatorQuestionNormalizer = Callable[..., str]
+RunHasExternalEvidenceWatchSignal = Callable[[dict[str, Any]], bool]
+SessionRuntimeProjectionFromRun = Callable[[Optional[dict[str, Any]]], Optional[dict[str, Any]]]
+PublicSafeText = Callable[..., Optional[str]]
+
+
+def goal_attention(
+    goal: dict[str, Any],
+    *,
+    latest_run: LatestRun,
+    readiness_attention_fields: AttentionFieldsBuilder,
+    operator_gate_attention_fields: AttentionFieldsBuilder,
+    dreaming_attention_fields: AttentionFieldsBuilder,
+    goal_lifecycle_fields: GoalLifecycleFields,
+    legacy_runtime_goal_attention: LegacyRuntimeGoalAttention,
+    compact_session_runtime_projection_from_run: SessionRuntimeProjectionFromRun,
+    public_safe_compact_text: PublicSafeText,
+    attention_item: AttentionItemBuilder,
+    run_has_external_evidence_watch_signal: RunHasExternalEvidenceWatchSignal,
+    default_operator_question: OperatorQuestionBuilder,
+    normalize_operator_question: OperatorQuestionNormalizer,
+    monitor_signal_waiting_on: str,
+    default_operator_gate: str,
+    planned_controller_opt_in_recommended_action: str,
+    connected_adapter_statuses: AbstractSet[str],
+    connected_delivery_adapter_statuses: AbstractSet[str],
+    registry_waiting_on_overrides: AbstractSet[str],
+    blocking_classifications: AbstractSet[str],
+    user_or_controller_classifications: AbstractSet[str],
+    codex_ready_classifications: AbstractSet[str],
+) -> dict[str, Any] | None:
+    goal_id = str(goal.get("id") or "unknown-goal")
+    adapter_status = str(goal.get("adapter_status") or "")
+    adapter_kind = str(goal.get("adapter_kind") or "")
+    current_run = latest_run(goal)
+    readiness_fields = readiness_attention_fields(current_run)
+    operator_gate_fields = operator_gate_attention_fields(current_run)
+    dreaming_fields = dreaming_attention_fields(current_run)
+    attention_fields = {**readiness_fields, **operator_gate_fields, **dreaming_fields}
+    lifecycle_fields = goal_lifecycle_fields(goal, current_run)
+
+    if goal.get("legacy_runtime_goal"):
+        return legacy_runtime_goal_attention(goal, current_run, readiness_fields)
+
+    if not current_run:
+        if (
+            adapter_status in connected_adapter_statuses
+            or adapter_status in connected_delivery_adapter_statuses
+        ):
+            return attention_item(
+                goal_id=goal_id,
+                status="connected_without_run",
+                waiting_on="codex",
+                severity="action",
+                recommended_action="run the first read-only adapter tick and save a compact run record",
+                source="run_history",
+                **lifecycle_fields,
+            )
+        if adapter_status == "planned" and adapter_kind.endswith("_read_only_map_v0"):
+            command = f"loopx read-only-map --goal-id {goal_id} --dry-run"
+            return attention_item(
+                goal_id=goal_id,
+                status=str(goal.get("status") or "planned"),
+                waiting_on="user_or_controller",
+                severity="action",
+                recommended_action=planned_controller_opt_in_recommended_action,
+                operator_question=default_operator_question(goal_id, default_operator_gate),
+                agent_command=command,
+                source="registry",
+                **lifecycle_fields,
+            )
+        return attention_item(
+            goal_id=goal_id,
+            status=str(goal.get("status") or "no_run"),
+            waiting_on="controller",
+            severity="action",
+            recommended_action="connect an adapter or run a read-only map before expecting runtime status",
+            source="registry",
+            **lifecycle_fields,
+        )
+
+    json_exists = bool(current_run.get("json_exists"))
+    markdown_exists = bool(current_run.get("markdown_exists"))
+    if not json_exists or not markdown_exists:
+        return attention_item(
+            goal_id=goal_id,
+            status="run_artifact_missing",
+            waiting_on="codex",
+            severity="high",
+            recommended_action="repair or regenerate the latest run artifacts before trusting status",
+            source="run_history",
+            **attention_fields,
+            **lifecycle_fields,
+        )
+
+    session_projection = compact_session_runtime_projection_from_run(current_run)
+    if session_projection:
+        return session_runtime_projection_attention(
+            goal,
+            current_run,
+            session_projection,
+            public_safe_compact_text=public_safe_compact_text,
+            attention_item=attention_item,
+            goal_lifecycle_fields=goal_lifecycle_fields,
+            monitor_signal_waiting_on=monitor_signal_waiting_on,
+        )
+
+    classification = str(current_run.get("classification") or "unknown")
+    action = str(current_run.get("recommended_action") or "inspect the latest run and choose one next action")
+    registry_waiting_on = str(goal.get("waiting_on") or "")
+    if registry_waiting_on in registry_waiting_on_overrides:
+        registry_attention_fields = dict(attention_fields)
+        if goal.get("operator_question"):
+            registry_attention_fields["operator_question"] = normalize_operator_question(
+                str(goal.get("operator_question") or ""),
+                goal_id=goal_id,
+                gate=str(goal.get("operator_gate") or default_operator_gate),
+            )
+        if goal.get("next_handoff_condition"):
+            registry_attention_fields["next_handoff_condition"] = str(goal.get("next_handoff_condition") or "")
+        return attention_item(
+            goal_id=goal_id,
+            status=str(goal.get("attention_status") or classification),
+            waiting_on=registry_waiting_on,
+            severity="watch" if registry_waiting_on == "external_evidence" else "action",
+            recommended_action=str(goal.get("recommended_action") or action),
+            source="registry",
+            **registry_attention_fields,
+            **lifecycle_fields,
+        )
+    if classification in blocking_classifications:
+        return attention_item(
+            goal_id=goal_id,
+            status=classification,
+            waiting_on="user_or_controller",
+            severity="high",
+            recommended_action=action,
+            source="latest_run",
+            **attention_fields,
+            **lifecycle_fields,
+        )
+    if classification in user_or_controller_classifications:
+        return attention_item(
+            goal_id=goal_id,
+            status=classification,
+            waiting_on="user_or_controller",
+            severity="action",
+            recommended_action=action,
+            source="latest_run",
+            **attention_fields,
+            **lifecycle_fields,
+        )
+    if classification in codex_ready_classifications:
+        return attention_item(
+            goal_id=goal_id,
+            status=classification,
+            waiting_on="codex",
+            severity="action",
+            recommended_action=action,
+            source="latest_run",
+            **attention_fields,
+            **lifecycle_fields,
+        )
+    if adapter_status in connected_delivery_adapter_statuses:
+        return attention_item(
+            goal_id=goal_id,
+            status=classification,
+            waiting_on="codex",
+            severity="action",
+            recommended_action=action,
+            source="latest_run",
+            **attention_fields,
+            **lifecycle_fields,
+        )
+    if run_has_external_evidence_watch_signal(current_run):
+        return attention_item(
+            goal_id=goal_id,
+            status=classification,
+            waiting_on="external_evidence",
+            severity="watch",
+            recommended_action=action,
+            source="latest_run",
+            **attention_fields,
+            **lifecycle_fields,
+        )
+    if adapter_status in connected_adapter_statuses:
+        return attention_item(
+            goal_id=goal_id,
+            status=classification,
+            waiting_on="codex",
+            severity="action",
+            recommended_action=action,
+            source="latest_run",
+            **attention_fields,
+            **lifecycle_fields,
+        )
+    return None