Show runtime owner and verification attempts in TUI

Status	File	+	-
M	`src/loader/runtime/runtime_api.py`	2	1
M	`src/loader/ui/adapter.py`	17	0
M	`src/loader/ui/app.py`	28	0
M	`src/loader/ui/status_helpers.py`	16	1
M	`src/loader/ui/widgets/status_line.py`	22	0
M	`tests/test_status_surfaces.py`	4	2

src/loader/runtime/runtime_api.pymodified

  from ..context.project import ProjectContext
  from ..tools.base import ToolRegistry
  from .capabilities import CapabilityProfile
 -from .events import AgentEvent
 +from .events import AgentEvent, TurnSummary
  from .session import ConversationSession
  RuntimeOwnerKind = Literal["runtime", "public-compat"]
      capability_profile: CapabilityProfile
      safeguards: object
      session: ConversationSession
 +    last_turn_summary: TurnSummary | None
      project_context: ProjectContext | None
      workflow_mode: str
      active_permission_mode: str

src/loader/ui/adapter.pymodified

      dod_status: str
      pending_items_count: int = 0
      last_verification_result: str | None = None
 +    verification_attempt: str | None = None
  @dataclass
                          dod_status=event.dod_status or "",
                          pending_items_count=event.pending_items_count or 0,
                          last_verification_result=event.last_verification_result,
 +                        verification_attempt=_definition_of_done_verification_attempt(
 +                            event.definition_of_done
 +                        ),
+                     )
+                 )
                          artifact_path=event.artifact_path or "",
+                     )
+                 )
++
++
 +def _definition_of_done_verification_attempt(dod) -> str | None:
 +    """Render one compact verification-attempt label from DoD state."""
++
 +    if dod is None:
 +        return None
 +    active_number = getattr(dod, "active_verification_attempt_number", None)
 +    if active_number is None:
 +        return None
 +    if getattr(dod, "last_verification_result", None) == "stale" and active_number > 1:
 +        return f"attempt {active_number - 1} -> attempt {active_number}"
 +    return f"attempt {active_number}"

src/loader/ui/app.pymodified

          status.mode = self.mode
          status.capability_profile = self.capability_profile
          status.session_id = self.session_id
 +        status.runtime_owner = self.shell_owner.session.runtime_owner_path or ""
          status.workflow_mode = self.workflow_mode
          status.turn_phase = self.turn_phase
          status.permission_mode = self.permission_mode
 +        if (
 +            self.shell_owner.last_turn_summary is not None
 +            and self.shell_owner.last_turn_summary.definition_of_done is not None
 +        ):
 +            dod = self.shell_owner.last_turn_summary.definition_of_done
 +            status.update_definition_of_done(
 +                dod.status,
 +                len(dod.pending_items),
 +                dod.last_verification_result,
 +                _definition_of_done_verification_attempt(dod),
 +            )
          # Focus input
          self.query_one(InputArea).focus_input()
              message.dod_status,
              message.pending_items_count,
              message.last_verification_result,
 +            message.verification_attempt,
+         )
      def on_workflow_mode_changed(self, message: WorkflowModeChanged) -> None:
          msg_area.remove_children()
          self.shell_owner.clear_history()
          self.query_one(StatusLine).clear_definition_of_done()
 +        self.query_one(StatusLine).update_session_id(self.shell_owner.session.session_id)
 +        self.query_one(StatusLine).update_runtime_owner(
 +            self.shell_owner.session.runtime_owner_path or ""
 +        )
          self.query_one(StatusLine).update_workflow_mode("execute")
          self._add_message("[dim]Conversation cleared.[/dim]")
          self.is_generating = False
          self._stop_timer()
          self.query_one(StatusLine).set_generating(False)
++
++
 +def _definition_of_done_verification_attempt(dod) -> str | None:
 +    """Render one compact verification-attempt label from DoD state."""
++
 +    active_number = getattr(dod, "active_verification_attempt_number", None)
 +    if active_number is None:
 +        return None
 +    if getattr(dod, "last_verification_result", None) == "stale" and active_number > 1:
 +        return f"attempt {active_number - 1} -> attempt {active_number}"
 +    return f"attempt {active_number}"

src/loader/ui/status_helpers.pymodified

  from __future__ import annotations
 +from ..runtime.owner_metadata import normalize_runtime_owner_path
++
  def format_definition_of_done_parts(
      status: str,
      pending_items_count: int,
      last_verification_result: str,
 +    verification_attempt: str = "",
  ) -> list[str]:
      """Format definition-of-done state for the status line."""
      if not status:
          verify_color = "green" if last_verification_result == "passed" else "red"
          if last_verification_result == "skipped":
              verify_color = "dim"
 +        verify_label = f"verify {last_verification_result}"
 +        if verification_attempt:
 +            verify_label = f"{verify_label} ({verification_attempt})"
          parts.append(
 -            f"[{verify_color}]verify {last_verification_result}[/{verify_color}]"
 +            f"[{verify_color}]{verify_label}[/{verify_color}]"
+         )
      return parts
      return f"[dim]session {session_id[-8:]}[/dim]"
 +def format_runtime_owner_part(owner_path: str) -> str | None:
 +    """Format the active runtime-owner path for the status line."""
++
 +    normalized_path = normalize_runtime_owner_path(owner_path)
 +    if not normalized_path:
 +        return None
 +    return f"[dim]owner {normalized_path}[/dim]"
++
++
  def format_workflow_mode_part(mode: str) -> str | None:
      """Format the active workflow mode for the status line."""

src/loader/ui/widgets/status_line.pymodified

      format_capability_part,
      format_definition_of_done_parts,
      format_permission_mode_part,
 +    format_runtime_owner_part,
      format_session_part,
      format_turn_phase_part,
      format_workflow_mode_part,
      mode: reactive[str] = reactive("Native")
      capability_profile: reactive[str] = reactive("")
      session_id: reactive[str] = reactive("")
 +    runtime_owner: reactive[str] = reactive("")
      workflow_mode: reactive[str] = reactive("")
      turn_phase: reactive[str] = reactive("")
      permission_mode: reactive[str] = reactive("")
      dod_status: reactive[str] = reactive("")
      pending_items_count: reactive[int] = reactive(0)
      last_verification_result: reactive[str] = reactive("")
 +    verification_attempt: reactive[str] = reactive("")
      def render(self) -> str:
          """Render the status line."""
                  self.dod_status,
                  self.pending_items_count,
                  self.last_verification_result,
 +                self.verification_attempt,
+             )
+         )
          session_part = format_session_part(self.session_id)
          if session_part:
              parts.append(session_part)
 +        runtime_owner = format_runtime_owner_part(self.runtime_owner)
 +        if runtime_owner:
 +            parts.append(runtime_owner)
          return " · ".join(parts) if parts else "[dim]Ready[/dim]"
          """React to session id changes."""
          self.refresh()
 +    def watch_runtime_owner(self, runtime_owner: str) -> None:
 +        """React to runtime owner changes."""
 +        self.refresh()
++
      def watch_workflow_mode(self, workflow_mode: str) -> None:
          """React to workflow mode changes."""
          self.refresh()
          """React to verification result changes."""
          self.refresh()
 +    def watch_verification_attempt(self, verification_attempt: str) -> None:
 +        """React to verification attempt changes."""
 +        self.refresh()
++
      def set_generating(self, is_generating: bool) -> None:
          """Set generating state."""
          if is_generating:
          """Update the active session id."""
          self.session_id = session_id
 +    def update_runtime_owner(self, runtime_owner: str) -> None:
 +        """Update the active runtime owner path."""
 +        self.runtime_owner = runtime_owner
++
      def update_workflow_mode(self, workflow_mode: str) -> None:
          """Update the active workflow mode."""
          self.workflow_mode = workflow_mode
          status: str,
          pending_items_count: int,
          last_verification_result: str | None,
 +        verification_attempt: str | None = None,
      ) -> None:
          """Update definition-of-done status."""
          self.dod_status = status
          self.pending_items_count = pending_items_count
          self.last_verification_result = last_verification_result or ""
 +        self.verification_attempt = verification_attempt or ""
      def clear_definition_of_done(self) -> None:
          """Clear definition-of-done status."""
          self.dod_status = ""
          self.pending_items_count = 0
          self.last_verification_result = ""
 +        self.verification_attempt = ""

tests/test_status_surfaces.pymodified

      format_capability_part,
      format_definition_of_done_parts,
      format_permission_mode_part,
 +    format_runtime_owner_part,
      format_session_part,
      format_turn_phase_part,
      format_workflow_mode_part,
  def test_status_helper_formats_definition_of_done_parts() -> None:
 -    parts = format_definition_of_done_parts("verifying", 1, "failed")
 +    parts = format_definition_of_done_parts("verifying", 1, "failed", "attempt 2")
      assert parts == [
          "[yellow]DoD: verifying[/yellow]",
          "[dim]1 pending[/dim]",
 -        "[red]verify failed[/red]",
 +        "[red]verify failed (attempt 2)[/red]",
+     ]
  def test_status_helpers_format_capability_and_session_parts() -> None:
      assert format_capability_part("native/strict") == "[dim]cap native/strict[/dim]"
      assert format_session_part("20260406T120000Z-abcdef01") == "[dim]session abcdef01[/dim]"
 +    assert format_runtime_owner_part("runtime-handle") == "[dim]owner runtime-handle[/dim]"

tenseleyflow/loader / `a488ab3`

6 changed files