refactor(orchestrator): implement semantic progress tracking

- Remove misleading 'Round X/Y' counter and time estimates
- Remove dead code (_get_progress_message, _EST_SECONDS_PER_ROUND)
- Implement semantic agent naming (e.g., 'reporter' -> 'ReportAgent')
- Update progress events to show 'Step N: AgentName task completed'
- Update tests to use valid domain agent IDs
- Fix P2_ROUND_COUNTER_SEMANTIC_MISMATCH

src/orchestrators/advanced.py

@@ -83,9 +83,6 @@ class AdvancedOrchestrator(OrchestratorProtocol):
     - Configurable timeouts and round limits
     """
 
-    # Estimated seconds per coordination round (for progress UI)
-    _EST_SECONDS_PER_ROUND: int = 45
-
     def __init__(
         self,
         max_rounds: int = 5,
@@ -193,16 +190,18 @@ Focus on:
 
 The final output should be a structured research report."""
 
-    def _get_progress_message(self, iteration: int) -> str:
-        """Generate progress message with time estimation."""
-        rounds_remaining = max(self._max_rounds - iteration, 0)
-        est_seconds = rounds_remaining * self._EST_SECONDS_PER_ROUND
-        if est_seconds >= 60:
-            est_display = f"{est_seconds // 60}m {est_seconds % 60}s"
-        else:
-            est_display = f"{est_seconds}s"
-
-        return f"Round {iteration}/{self._max_rounds} (~{est_display} remaining)"
+    def _get_agent_semantic_name(self, agent_id: str) -> str:
+        """Map internal agent ID to user-facing semantic name."""
+        name = agent_id.lower()
+        if SEARCHER_AGENT_ID in name:
+            return "SearchAgent"
+        if JUDGE_AGENT_ID in name:
+            return "JudgeAgent"
+        if HYPOTHESIZER_AGENT_ID in name:
+            return "HypothesisAgent"
+        if REPORTER_AGENT_ID in name:
+            return "ReportAgent"
+        return "ManagerAgent"
 
     async def _init_workflow_events(self, query: str) -> AsyncGenerator[AgentEvent, None]:
         """Yield initialization events."""
@@ -219,7 +218,9 @@ The final output should be a structured research report."""
         )
 
     async def _synthesize_fallback(
-        self, iteration: int, reason: str
+        self,
+        iteration: int,
+        reason: str,
     ) -> AsyncGenerator[AgentEvent, None]:
         """
         Unified fallback synthesis for all termination scenarios.
@@ -272,7 +273,8 @@ The final output should be a structured research report."""
             )
 
     async def run(  # noqa: PLR0915 - Complex but necessary for event stream handling
-        self, query: str
+        self,
+        query: str,
     ) -> AsyncGenerator[AgentEvent, None]:
         """
         Run the workflow.
@@ -312,9 +314,8 @@ The final output should be a structured research report."""
         yield AgentEvent(
             type="thinking",
             message=(
-                f"Multi-agent reasoning in progress ({self._max_rounds} rounds max)... "
-                f"Estimated time: {self._max_rounds * 45 // 60}-"
-                f"{self._max_rounds * 60 // 60} minutes."
+                f"Multi-agent reasoning in progress (Limit: {self._max_rounds} Manager rounds)... "
+                "Allocating time for deep research..."
             ),
             iteration=0,
         )
@@ -434,7 +435,10 @@ The final output should be a structured research report."""
             )
 
     def _handle_completion_event(
-        self, event: ExecutorCompletedEvent, buffer: str, iteration: int
+        self,
+        event: ExecutorCompletedEvent,
+        buffer: str,
+        iteration: int,
     ) -> tuple[AgentEvent, AgentEvent]:
         """Handle an agent completion event using the accumulated buffer."""
         # Use buffer if available, otherwise fall back cautiously
@@ -446,25 +450,19 @@ The final output should be a structured research report."""
             # The result is often in event.result or similar, but buffering is safer
             text_content = "Action completed (Tool Call)"
 
-        agent_name = getattr(event, "executor_id", "unknown") or "unknown"
-        event_type = self._get_event_type_for_agent(agent_name)
+        agent_id = getattr(event, "executor_id", "unknown") or "unknown"
+        event_type = self._get_event_type_for_agent(agent_id)
+        semantic_name = self._get_agent_semantic_name(agent_id)
 
         completion_event = AgentEvent(
             type=event_type,
-            message=f"{agent_name}: {text_content[:200]}...",
+            message=f"{semantic_name}: {text_content[:200]}...",
             iteration=iteration,
         )
 
-        # Progress update
-        rounds_remaining = max(self._max_rounds - iteration, 0)
-        est_seconds = rounds_remaining * 45
-        est_display = (
-            f"{est_seconds // 60}m {est_seconds % 60}s" if est_seconds >= 60 else f"{est_seconds}s"
-        )
-
         progress_event = AgentEvent(
             type="progress",
-            message=f"Round {iteration}/{self._max_rounds} (~{est_display} remaining)",
+            message=f"Step {iteration}: {semantic_name} task completed",
             iteration=iteration,
         )
 
@@ -552,7 +550,8 @@ The final output should be a structured research report."""
         return ""
 
     def _get_event_type_for_agent(
-        self, agent_name: str
+        self,
+        agent_name: str,
     ) -> Literal["search_complete", "judge_complete", "hypothesizing", "synthesizing", "judging"]:
         """Map agent name to appropriate event type.
 

tests/unit/orchestrators/test_accumulator_pattern.py

@@ -174,10 +174,11 @@ async def test_accumulator_pattern_scenario_a_standard_text(mock_orchestrator):
     Input: Updates ("Hello", " World") -> Completed
     Expected: AgentEvent with "Hello World"
     """
+    # Use "searcher" to map to "SearchAgent"
     events = [
-        MockAgentRunUpdateEvent("Hello", author_name="ChatBot"),
-        MockAgentRunUpdateEvent(" World", author_name="ChatBot"),
-        MockExecutorCompletedEvent(executor_id="ChatBot"),
+        MockAgentRunUpdateEvent("Hello", author_name="searcher"),
+        MockAgentRunUpdateEvent(" World", author_name="searcher"),
+        MockExecutorCompletedEvent(executor_id="searcher"),
     ]
 
     async def mock_stream(*args, **kwargs):
@@ -192,13 +193,13 @@ async def test_accumulator_pattern_scenario_a_standard_text(mock_orchestrator):
         async for event in mock_orchestrator.run("test query"):
             generated_events.append(event)
 
-    # Find the completion event for ChatBot (non-streaming)
+    # Find the completion event for SearchAgent (non-streaming)
     chat_events = [
-        e for e in generated_events if "ChatBot" in str(e.message) and e.type != "streaming"
+        e for e in generated_events if "SearchAgent" in str(e.message) and e.type != "streaming"
     ]
 
     assert len(chat_events) >= 1, (
-        f"Expected ChatBot events, got: {[e.message for e in generated_events]}"
+        f"Expected SearchAgent events, got: {[e.message for e in generated_events]}"
     )
     final_event = chat_events[0]
 
@@ -214,8 +215,9 @@ async def test_accumulator_pattern_scenario_b_tool_call(mock_orchestrator):
     Input: No Deltas -> Completed
     Expected: AgentEvent with fallback text
     """
+    # Use "searcher" to map to "SearchAgent"
     events = [
-        MockExecutorCompletedEvent(executor_id="SearchAgent"),
+        MockExecutorCompletedEvent(executor_id="searcher"),
     ]
 
     async def mock_stream(*args, **kwargs):
@@ -251,11 +253,12 @@ async def test_accumulator_pattern_buffer_clearing(mock_orchestrator):
     Verify buffer clears between agents.
     Agent B should NOT inherit Agent A's accumulated text.
     """
+    # Use "searcher" (SearchAgent) and "judge" (JudgeAgent)
     events = [
-        MockAgentRunUpdateEvent("Agent A says hi", author_name="AgentA"),
-        MockExecutorCompletedEvent(executor_id="AgentA"),
-        MockAgentRunUpdateEvent("Agent B responds", author_name="AgentB"),
-        MockExecutorCompletedEvent(executor_id="AgentB"),
+        MockAgentRunUpdateEvent("Searcher says hi", author_name="searcher"),
+        MockExecutorCompletedEvent(executor_id="searcher"),
+        MockAgentRunUpdateEvent("Judge responds", author_name="judge"),
+        MockExecutorCompletedEvent(executor_id="judge"),
     ]
 
     async def mock_stream(*args, **kwargs):
@@ -272,18 +275,22 @@ async def test_accumulator_pattern_buffer_clearing(mock_orchestrator):
 
     # Find non-streaming events for each agent
     agent_a_events = [
-        e for e in generated_events if "AgentA" in str(e.message) and e.type != "streaming"
+        e for e in generated_events if "SearchAgent" in str(e.message) and e.type != "streaming"
     ]
     agent_b_events = [
-        e for e in generated_events if "AgentB" in str(e.message) and e.type != "streaming"
+        e for e in generated_events if "JudgeAgent" in str(e.message) and e.type != "streaming"
     ]
 
     # Both should have completion events
-    assert len(agent_a_events) >= 1, f"No AgentA events: {[e.message for e in generated_events]}"
-    assert len(agent_b_events) >= 1, f"No AgentB events: {[e.message for e in generated_events]}"
+    assert len(agent_a_events) >= 1, (
+        f"No SearchAgent events: {[e.message for e in generated_events]}"
+    )
+    assert len(agent_b_events) >= 1, (
+        f"No JudgeAgent events: {[e.message for e in generated_events]}"
+    )
 
     # Agent A should have its own text
-    assert "Agent A" in agent_a_events[0].message
+    assert "Searcher" in agent_a_events[0].message
     # Agent B should have its own text, NOT Agent A's
-    assert "Agent B" in agent_b_events[0].message
-    assert "Agent A" not in agent_b_events[0].message, "Buffer not cleared between agents!"
+    assert "Judge" in agent_b_events[0].message
+    assert "Searcher" not in agent_b_events[0].message, "Buffer not cleared between agents!"