fix(studio): report each migration turn's own cost

The migration page showed what Codex did but never what it cost: no turn
duration, no tool time, no tokens. The intelligent build reports all three
from the app-server's turn lifecycle, and the migration feed renders the
same summary component, so the reader now settles one turn per source.

A tool-driven migration turn ends the moment its result lands, which is why
the app-server never saw turn_completed and the usage stayed invisible.
Turns now settle from the app-server's own turn record read back before the
session closes, and the in-Sandbox `codex exec --json` turn — which writes a
bare terminal line with snake_case usage and no timestamps — settles from
that line, with the total computed the way the app-server reports it.

The sandbox exec stream carries no timing at all, so those rows say the
duration was not reported rather than inventing one.

Author: wujiaming-ai

frontend/server/migration/activity.py

@@ -44,6 +44,17 @@
 _COMPLETED_STATUSES = {"completed", "done"}
 _FAILED_STATUSES = {"failed", "error", "declined"}
 
+# The turn's own verdict, which the reader renders as one summary row the way the
+# intelligent build renders its ``turn-summary`` block.
+_TERMINAL_TURN_STATUSES = {"completed", "failed", "cancelled", "interrupted"}
+_TURN_EVENT_TYPES = {
+    "completed": "turn.completed",
+    "failed": "turn.failed",
+    "cancelled": "turn.interrupted",
+    "interrupted": "turn.interrupted",
+}
+_TURN_FIELDS = ("startedAt", "completedAt", "durationMs", "model")
+
 _TOOL_ITEM_TYPES = {
     "commandExecution": "command_execution",
     "fileChange": "file_change",
@@ -62,6 +73,13 @@
 }
 
 
+def _turn_status(value: object) -> str:
+    """Read the turn status the app-server reports as a string or a tagged object."""
+    if isinstance(value, dict):
+        value = value.get("type")
+    return str(value or "").strip().lower()
+
+
 def _text(value: object, limit: int = _MAX_TEXT_CHARS) -> str:
     if not isinstance(value, str):
         return ""
@@ -107,13 +125,18 @@ def __init__(
         self._outputs: dict[str, str] = {}
         self._names: dict[str, str] = {}
         self._commands: dict[str, str] = {}
+        self._turn: dict[str, object] = {}
+        self._usage: dict[str, object] = {}
 
     @property
     def lines(self) -> list[str]:
         return list(self._lines)
 
     def line(self, event: CodexAppServerEvent) -> dict[str, object] | None:
         """One ``codex exec --json`` line for ``event``; ``None`` when it has no item."""
+        turn = self._turn_line(event)
+        if turn is not None:
+            return turn
         item = self._item(event)
         if item is None:
             return None
@@ -196,6 +219,49 @@ def _content(self) -> bytes:
             size -= len(lines.pop(0)) + 1
         return ("\n".join(lines) + "\n").encode("utf-8") if lines else b""
 
+    def _turn_line(self, event: CodexAppServerEvent) -> dict[str, object] | None:
+        """One line for the turn's own cost, written when the turn settles.
+
+        The page reports the same turn metrics the intelligent build does — how long
+        the turn took, how many tools it ran, what it cost in tokens — and the
+        intelligent build reads them off the app-server's turn lifecycle and usage
+        events rather than off any item.  Items never carry them, so they are
+        accumulated here and written as one ``turn.*`` line that the reader turns into
+        a summary of everything logged before it.
+        """
+        kind = str(event.kind or "")
+        if kind == "usage":
+            if event.usage is not None:
+                self._usage["usage"] = event.usage.public_dict()
+            if event.thread_total is not None:
+                self._usage["thread_total"] = event.thread_total.public_dict()
+            window = event.model_context_window
+            if isinstance(window, int) and not isinstance(window, bool):
+                self._usage["model_context_window"] = window
+            return None
+        if kind not in {"turn_started", "turn_completed"}:
+            return None
+        response = event.response if isinstance(event.response, dict) else {}
+        turn = {**self._turn, **response}
+        if event.turn_id:
+            turn["id"] = event.turn_id
+        status = _turn_status(event.status or turn.get("status"))
+        if kind == "turn_started" or status not in _TERMINAL_TURN_STATUSES:
+            self._turn = turn
+            return None
+        summary: dict[str, object] = {
+            "type": _TURN_EVENT_TYPES.get(status, "turn.completed"),
+            "turn": {
+                "id": str(turn.get("id") or ""),
+                "status": status,
+                **{key: turn[key] for key in _TURN_FIELDS if key in turn},
+            },
+        }
+        summary.update(self._usage)
+        self._turn = {}
+        self._usage = {}
+        return summary
+
     def _event_type(self, event: CodexAppServerEvent) -> str:
         status = str(event.status or "").lower()
         if status in _FAILED_STATUSES:

frontend/server/migration/codex_tool_turn.py

@@ -25,6 +25,7 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass
 
@@ -39,6 +40,15 @@
     "CodexDynamicToolResult | Awaitable[CodexDynamicToolResult]",
 ]
 
+logger = logging.getLogger(__name__)
+
+# A turn that is interrupted the moment its result lands needs its own settlement, and
+# the app-server needs a moment to record the interruption before the turn reads back
+# as terminal.
+_TURN_SETTLE_ATTEMPTS = 6
+_TURN_SETTLE_SECONDS = 0.5
+_TERMINAL_TURN_STATUSES = {"completed", "failed", "interrupted", "cancelled"}
+
 __all__ = [
     "DynamicTool",
     "ToolHandler",
@@ -126,6 +136,7 @@ async def run_tool_turn(
             tool.handler,
         )
     used_thread = thread_id
+    turn_id = ""
     loop = asyncio.get_running_loop()
     try:
         try:
@@ -144,7 +155,11 @@ async def run_tool_turn(
             async for event in session.stream_turn(
                 prompt,
                 timeout_seconds=idle_timeout,
+                # 本轮耗时/模型要跟智能构建一样报给页面，所以即使这不是 Studio
+                # 任务回合也要收生命周期事件。
+                emit_turn_lifecycle=True,
             ):
+                turn_id = str(getattr(event, "turn_id", "") or "") or turn_id
                 if event_sink is not None:
                     event_sink(event)
                 if has_result():
@@ -170,5 +185,83 @@ async def run_tool_turn(
                 raise ToolTurnUnavailable(str(error)) from error
         used_thread = session.thread_id or thread_id
     finally:
+        # 结果一到手就打断的回合（以及超时收尾的回合）都走不到 app-server 的
+        # turn_completed，而本轮耗时/模型只挂在那条事件上：会话还在的时候回读这一轮，
+        # 替它补一条结算，页面才能像智能构建那样报出本轮的成本。
+        await _settle_turn(
+            session,
+            event_sink,
+            turn_id=turn_id or str(getattr(session, "active_turn_id", "") or ""),
+            accepted=has_result(),
+        )
         await session.close()
     return used_thread
+
+
+def _turn_status(turn: dict[str, object]) -> str:
+    status = turn.get("status")
+    if isinstance(status, dict):
+        status = status.get("type")
+    return str(status or "").strip().lower()
+
+
+async def _settle_turn(
+    session: CodexAppServerSession,
+    event_sink: Callable[[object], None] | None,
+    *,
+    turn_id: str,
+    accepted: bool,
+) -> None:
+    """Report a turn's own timing when the caller stopped it before the app-server did.
+
+    Breaking out of the stream once the result arrives (or at the caller's deadline)
+    leaves the turn without a ``turn_completed`` event, so codex' native timing
+    (``startedAt`` / ``completedAt`` / ``durationMs`` / ``model``) never reaches the
+    page.  Reading the turn back keeps those numbers, and ``accepted`` says the caller
+    took the result: the turn delivered what it was asked for, whatever codex calls the
+    interruption the caller requested.
+
+    Settlement is decoration on top of the turn's real outcome, so it never raises.
+    """
+    if event_sink is None or not turn_id:
+        return
+    try:
+        read_turn = getattr(session, "read_turn", None)
+        lifecycle = getattr(session, "turn_lifecycle_event", None)
+        if not callable(read_turn) or not callable(lifecycle):
+            return
+        turn: dict[str, object] | None = None
+        for attempt in range(_TURN_SETTLE_ATTEMPTS):
+            candidate = await read_turn(turn_id)
+            if not isinstance(candidate, dict):
+                return
+            turn = candidate
+            if _turn_status(turn) in _TERMINAL_TURN_STATUSES:
+                break
+            if attempt + 1 < _TURN_SETTLE_ATTEMPTS:
+                await asyncio.sleep(_TURN_SETTLE_SECONDS)
+        if turn is None:
+            return
+        status = _turn_status(turn)
+        if accepted:
+            turn = {**turn, "status": "completed"}
+        elif status not in _TERMINAL_TURN_STATUSES:
+            # 既没拿到结果、这一轮又还在跑：没有可以报的终态，不编一个。
+            return
+        if "durationMs" not in turn:
+            # 回合自己的时间戳就是权威值，缺 durationMs 时由它俩相减得出。
+            started, completed = turn.get("startedAt"), turn.get("completedAt")
+            if (
+                isinstance(started, (int, float))
+                and not isinstance(started, bool)
+                and isinstance(completed, (int, float))
+                and not isinstance(completed, bool)
+                and completed >= started
+            ):
+                turn = {**turn, "durationMs": completed - started}
+        event_sink(lifecycle("turn_completed", turn))
+    except Exception as error:  # noqa: BLE001 - 读数是装饰，不能改变回合结果
+        logger.warning(
+            "Studio migration turn settlement failed error_type=%s",
+            type(error).__name__,
+        )