fix(work): keep narration truthful across steer

Fence stale pre-steer narration and status evidence, preserve evidence strength, and keep mechanical intake or unstructured tool output from masquerading as semantic progress.

Author: Lucas1479

agent_host/adapters/codex_app_server.py

@@ -1183,27 +1183,53 @@ def _map_notification(
         )
         name = self._tool_name(safe_item_type, item)
         if method == "item/started":
-            return [
-                self._event(
-                    active,
-                    "tool.call",
-                    {
-                        "name": name,
-                        "item_id": item_id,
-                        "input": self._tool_input(safe_item_type, item),
-                    },
+            tool_input = self._tool_input(safe_item_type, item)
+            call_payload: dict[str, Any] = {
+                "tool": name,
+                "name": name,
+                "item_id": item_id,
+                "input": tool_input,
+            }
+            if isinstance(tool_input, dict):
+                command = str(tool_input.get("command") or "").strip()
+                title = " ".join(str(tool_input.get("title") or "").split())[:240]
+                changes = tool_input.get("changes")
+                if command:
+                    call_payload["command"] = command[:2000]
+                if title:
+                    call_payload["title"] = title
+                if isinstance(changes, list):
+                    call_payload["changes"] = changes
+            events = []
+            direction = self._reported_tool_direction(safe_item_type, tool_input)
+            if direction:
+                events.append(
+                    self._event(
+                        active,
+                        "assistant.update",
+                        {
+                            "text": direction,
+                            "source": "codex_native_tool_title",
+                            "explicit": False,
+                            "status": "reported_direction",
+                        },
+                    )
                 )
-            ]
+            events.append(self._event(active, "tool.call", call_payload))
+            return events
         success = self._item_succeeded(item)
         if not success:
             state.tool_failures += 1
         result_payload: dict[str, Any] = {
+            "tool": name,
             "name": name,
             "item_id": item_id,
             "success": success,
             "status": str(item.get("status") or ""),
             "output": self._tool_output(item),
         }
+        if safe_item_type == "commandExecution":
+            result_payload["exit_code"] = item.get("exitCode")
         if safe_item_type == "fileChange":
             result_payload["changes"] = self._file_changes(item)
         events = [
@@ -1505,6 +1531,16 @@ def _tool_input(item_type: str, item: dict[str, Any]) -> Any:
             return {"changes": CodexAppServerAdapter._file_changes(item)}
         return item.get("arguments") or item.get("query") or {}
 
+    @staticmethod
+    def _reported_tool_direction(item_type: str, tool_input: Any) -> str:
+        """Return only the native human-facing title, never code or tool output."""
+
+        if item_type in {"commandExecution", "fileChange"} or not isinstance(
+            tool_input, dict
+        ):
+            return ""
+        return " ".join(str(tool_input.get("title") or "").split())[:240]
+
     @staticmethod
     def _file_changes(item: dict[str, Any]) -> list[dict[str, str]]:
         raw = item.get("changes") if isinstance(item.get("changes"), list) else []

server/handlers/work_activity_handler.py

@@ -244,11 +244,6 @@ async def _on_provider_event(self, _method: str, params: dict[str, Any]) -> None
                 phase="Intake",
                 progress=10,
                 force=True,
-                # The Host knows which bounded goal it just dispatched even
-                # before the Provider reports an implementation milestone.
-                # Surface that one truthful direction so a long cold start is
-                # not two minutes of silence; results remain receipt-owned.
-                narration_keypoint="directional_progress",
             )
             return
 
@@ -831,6 +826,7 @@ def _accept_semantic_fact(
         state["semantic_explicit"] = fact.explicit
         state["semantic_verified"] = fact.verified
         state["semantic_milestone"] = fact.milestone
+        state["semantic_evidence"] = fact.evidence
         return True
 
     @staticmethod
@@ -1495,8 +1491,23 @@ async def _emit_progress_canvas(
                 {
                     "narration_keypoint": narration_keypoint,
                     **(
-                        {"semantic_milestone": str(state.get("semantic_milestone") or "")}
-                        if semantic and state.get("semantic_milestone")
+                        {
+                            **(
+                                {
+                                    "semantic_milestone": str(
+                                        state.get("semantic_milestone") or ""
+                                    )
+                                }
+                                if state.get("semantic_milestone")
+                                else {}
+                            ),
+                            "semantic_source": str(state.get("semantic_source") or ""),
+                            "semantic_verified": state.get("semantic_verified") is True,
+                            "semantic_evidence": str(
+                                state.get("semantic_evidence") or "reported"
+                            ),
+                        }
+                        if semantic and not semantic_candidate
                         else {}
                     ),
                     **(
@@ -2001,9 +2012,11 @@ def _progress_signals(
                     label="report" if semantic else "stream",
                     text=self._trim(text, 110),
                     detail=(
-                        "provider update; not terminal"
+                        "reported direction; not verified"
                         if semantic_candidate
-                        else "semantic"
+                        else "Host-observed semantic evidence"
+                        if semantic and state.get("semantic_verified") is True
+                        else "provider-reported semantic evidence; not verified"
                         if semantic
                         else "streaming"
                     ),