okstra 0.190.0 → 0.191.1

package/runtime/python/okstra_token_usage/collect.py

@@ -19,6 +19,7 @@ from .codex import (
     codex_session_ids,
     codex_session_is_worker,
     codex_session_total,
+    codex_session_window_total,
     find_codex_sessions,
 )
 from .antigravity import (
@@ -31,10 +32,11 @@ from .grok import (
     find_grok_sessions,
     grok_session_is_non_interactive,
     grok_session_total,
+    grok_session_window_total,
 )
-from .paths import claude_project_dir, utc_now
+from .paths import claude_project_dir, find_session_jsonl, utc_now
 from .pricing import antigravity_cost_usd, provider_cost_usd
-from okstra_ctl.dispatch_state import worker_session_ids
+from okstra_ctl.dispatch_state import worker_dispatch_records, worker_session_ids
 from okstra_ctl.models import provider_wrappers
 from okstra_ctl.wrapper_status import (
     log_path_for_prompt,
@@ -637,11 +639,21 @@ def _cli_sessions_for_windows(
     return sessions
 
 
-def _cli_session_totals(provider: str, session_paths: list[Path]) -> list[dict]:
+def _cli_session_totals(
+    provider: str,
+    session_paths: list[Path],
+    *,
+    window: tuple[str, str] | None = None,
+) -> list[dict]:
+    """세션별 합계. `window` 는 리드 전용 — run 보다 먼저 열린 세션을 창으로 자른다."""
     totals = []
     for session_path in session_paths:
-        if provider == "codex":
+        if provider == "codex" and window is not None:
+            total = codex_session_window_total(session_path, *window)
+        elif provider == "codex":
             total = codex_session_total(session_path)
+        elif provider == "grok" and window is not None:
+            total = grok_session_window_total(session_path, *window)
         elif provider == "antigravity":
             total = (
                 antigravity_status_total(session_path)
@@ -778,19 +790,50 @@ def collect_cli_usage(
     return block
 
 
-def _worker_cli_windows(
-    project_root: Path,
-    worker: dict,
-    fallback_windows: list[tuple[str, str]],
-) -> tuple[list[tuple[str, str]], Path | None, bool]:
-    prompt_path = _resolve_project_path(project_root, str(worker.get("promptPath") or ""))
+def _prompt_cli_window(
+    project_root: Path, prompt_path_raw: str,
+) -> tuple[tuple[str, str] | None, Path | None]:
+    """한 dispatch 의 래퍼 창 — 프롬프트 옆 status 사이드카의 started/ended."""
+    prompt_path = _resolve_project_path(project_root, prompt_path_raw)
     status_path = status_path_for_prompt(prompt_path) if prompt_path is not None else None
     execution = wrapper_execution(status_path)
     started_at = execution.get("startedAt")
-    ended_at = execution.get("endedAt")
-    if started_at:
-        return [(started_at, ended_at or utc_now())], status_path, False
-    return fallback_windows, status_path, True
+    if not started_at:
+        return None, status_path
+    return (started_at, execution.get("endedAt") or utc_now()), status_path
+
+
+def _worker_prompt_paths(worker: dict, records: list[dict]) -> list[str]:
+    """이 워커가 띄운 dispatch 의 프롬프트 경로 전부 — 원장 행이 없으면(v1) 명부 행의 하나."""
+    paths: list[str] = []
+    for record in records:
+        raw = str(record.get("promptPath") or "").strip()
+        if raw and raw not in paths:
+            paths.append(raw)
+    if not paths:
+        raw = str(worker.get("promptPath") or "").strip()
+        if raw:
+            paths.append(raw)
+    return paths
+
+
+def _worker_session_cwds(project_root: Path, records: list[dict]) -> list[Path]:
+    """세션 디렉터리가 인코딩된 cwd 후보 — grok·kimi 는 워크트리 안에서 돈다.
+
+    `providers/grok/adapter.py` 는 `request.worktree_path or request.project_root`
+    를 cwd 로 넘기고 세션 디렉터리는 그 경로를 퍼센트 인코딩한 이름이다. 프로젝트
+    루트로만 찾으면 워크트리 안에서 돈 세션은 0건이다(실측 2026-09-08 jobs
+    implementation-planning r01: grok critic 세션이 워크트리 이름 아래 있었다).
+    codex·claude 는 루트에서 돌므로 워크트리 후보는 빈 결과로 끝난다.
+    """
+    cwds: list[Path] = []
+    for record in records:
+        raw = str(record.get("worktreePath") or "").strip()
+        if raw and Path(raw) not in cwds:
+            cwds.append(Path(raw))
+    if project_root not in cwds:
+        cwds.append(project_root)
+    return cwds
 
 
 def _antigravity_usage_sources(
@@ -828,25 +871,114 @@ def _worker_cli_usage_block(
     provider: str,
     project_root: Path,
     worker: dict,
+    records: list[dict],
     fallback_windows: list[tuple[str, str]],
 ) -> dict:
-    """공급자 프로세스 트랜스크립트와 실행 증거로 워커 사용량 블록을 만든다."""
-    windows, status_path, used_fallback = _worker_cli_windows(
-        project_root,
-        worker,
-        fallback_windows,
-    )
-    session_paths = _cli_sessions_for_windows(provider, project_root, windows)
+    """공급자 프로세스 트랜스크립트와 실행 증거로 워커 사용량 블록을 만든다.
+
+    dispatch 원장 행마다 래퍼 창을 하나씩 잡아 그 창의 세션을 전부 합산한다 —
+    재검증·critic-gap·plan-verify 로 다시 띄운 실행이 각각 새 세션이므로
+    첫 프롬프트 하나만 보면 나머지는 통째로 빠진다. 실행 상태는 마지막
+    dispatch 의 것, 소요 시간은 래퍼 창의 합이다.
+    """
+    windows: list[tuple[str, str]] = []
+    prompt_paths = _worker_prompt_paths(worker, records)
+    status_paths: list[Path | None] = []
+    for raw in prompt_paths:
+        window, status_path = _prompt_cli_window(project_root, raw)
+        status_paths.append(status_path)
+        if window is not None:
+            windows.append(window)
+    used_fallback = not windows
+    if used_fallback:
+        windows = fallback_windows
+    session_paths: list[Path] = []
+    for cwd in _worker_session_cwds(project_root, records):
+        for path in _cli_sessions_for_windows(provider, cwd, windows):
+            if path not in session_paths:
+                session_paths.append(path)
+    status_path = status_paths[-1] if status_paths else None
     if provider == "antigravity":
-        for source in _antigravity_usage_sources(project_root, worker, status_path):
-            if source not in session_paths:
-                session_paths.append(source)
-    return collect_cli_usage(
+        for raw, source_status in zip(prompt_paths, status_paths):
+            for source in _antigravity_usage_sources(
+                project_root, {"promptPath": raw}, source_status,
+            ):
+                if source not in session_paths:
+                    session_paths.append(source)
+    block = collect_cli_usage(
         provider=provider,
         status_path=status_path,
         sessions=session_paths,
         fallback_window_used=used_fallback,
     )
+    durations = [
+        wrapper_execution(path).get("durationMs")
+        for path in status_paths
+        if path is not None
+    ]
+    measured = [value for value in durations if isinstance(value, int)]
+    if len(measured) > 1:
+        block["durationMs"] = sum(measured)
+    return block
+
+
+def _wrapper_claude_worker(worker: dict) -> bool:
+    """호스트가 claude 가 아닐 때 래퍼로 띄운 claude 워커."""
+    provider = str(worker.get("provider") or worker.get("agent") or "").strip()
+    runner = str(worker.get("runner") or "").strip()
+    return provider in _SESSION_JSONL_PROVIDERS and runner in {"", "cli-wrapper"}
+
+
+def _claude_wrapper_usage_block(
+    *,
+    project_root: Path,
+    worker_id: str,
+    state: dict,
+    window: tuple[str | None, str | None],
+    incremental: bool,
+) -> dict:
+    """래퍼로 띄운 claude 워커의 세션 jsonl — dispatch 가 발급한 세션 id 로 찾는다.
+
+    `okstra-claude-exec.sh` 는 `claude -p --session-id <id>` 로 돌고 그 id 는
+    `workerDispatches[].sessionId` 에 적힌다(`_dispatch_record`). 트랜스크립트는
+    `~/.claude/projects/<루트 인코딩>/<id>.jsonl` 에 있는데, claude 가 아닌
+    호스트의 수집기는 이 워커를 "세션 jsonl 공급자" 라며 건너뛰어 항상
+    `unavailable` 이었다(실측 2026-09-08 jobs implementation-planning r01:
+    claude planner 5회·report-writer 2회 세션이 전부 디스크에 있었다). claude
+    호스트의 `collect_claude_runtime_usage` 가 같은 id 로 하는 일을 여기서 한다.
+    """
+    since, until = window
+    session_ids = worker_session_ids(state, worker_id)
+    if not session_ids:
+        return na_block(
+            "claude wrapper worker has no dispatch session id recorded in workerDispatches"
+        )
+    totals: list[dict] = []
+    paths: list[Path] = []
+    attributed: list[str] = []
+    for session_id in session_ids:
+        path = find_session_jsonl(session_id, project_root)
+        if path is None:
+            continue
+        session_totals = claude_session_totals(
+            path, since=since, until=until, incremental=incremental,
+        )
+        # 창 밖 세션은 0 토큰 totals 가 되어 허위 0 으로 보고된다 — claude 호스트
+        # 경로와 같은 `startedAt` 검사로 거른다.
+        if not session_totals.get("startedAt"):
+            continue
+        totals.append(session_totals)
+        paths.append(path)
+        attributed.append(session_id)
+    if not totals:
+        return na_block(
+            "claude session jsonl not found under "
+            f"{claude_project_dir(project_root)} for dispatch session ids {session_ids}"
+        )
+    block = usage_block(_aggregate_totals(totals), source="claude-jsonl")
+    block["sessionIds"] = attributed
+    block["sessionPaths"] = [str(path) for path in paths]
+    return block
 
 
 def _attach_cli_usage(
@@ -886,27 +1018,46 @@ def _attach_cli_usage(
 
 
 def _collect_cli_runtime_usage(
-    state: dict, project_root: Path, team_state_path: Path | None = None,
+    state: dict,
+    project_root: Path,
+    team_state_path: Path | None = None,
+    *,
+    incremental: bool = True,
 ) -> dict:
     windows_by_worker = _codex_worker_windows(project_root, state)
+    run_window: tuple[str | None, str | None] = (None, None)
+    if team_state_path is not None:
+        run_window = resolve_run_window(team_state_path, state)
     for worker in state.get("workers", []):
         if not isinstance(worker, dict):
             continue
+        worker_id = str(worker.get("workerId") or "").strip()
+        records = [
+            dict(record) for record in worker_dispatch_records(state, worker_id)
+        ] if worker_id else []
         provider = _cli_assignment_provider(worker)
-        if not provider:
+        if provider:
+            worker["usage"] = _worker_cli_usage_block(
+                provider=provider,
+                project_root=project_root,
+                worker=worker,
+                records=records,
+                fallback_windows=windows_by_worker.get(worker_id, []),
+            )
+        elif worker_id and _wrapper_claude_worker(worker):
+            worker["usage"] = _claude_wrapper_usage_block(
+                project_root=project_root,
+                worker_id=worker_id,
+                state=state,
+                window=run_window,
+                incremental=incremental,
+            )
+        else:
             worker["usage"] = na_block(
                 "worker usage is not read from a provider CLI transcript "
-                "(host-native, session-jsonl provider, or no registered CLI provider): "
+                "(host-native or no registered CLI provider): "
                 f"{worker.get('provider') or worker.get('agent') or worker.get('workerId')}"
             )
-            continue
-        worker_id = str(worker.get("workerId") or "").strip()
-        worker["usage"] = _worker_cli_usage_block(
-            provider=provider,
-            project_root=project_root,
-            worker=worker,
-            fallback_windows=windows_by_worker.get(worker_id, []),
-        )
     state["leadUsage"] = _cli_lead_usage(state, project_root, team_state_path)
     _populate_usage_summary(state, team_name=resolve_team_name(state),
                             sessions_found=0, needle_source="none")
@@ -952,22 +1103,29 @@ def _cli_lead_usage(
         if isinstance(worker, dict)
         for path in ((worker.get("usage") or {}).get("cliSessionPaths") or [])
     }
+    # in-session 리드(codex·grok)는 run 보다 먼저 열린 세션이다 — 창 안에서
+    # 시작한 세션만 보면 없다고 나오고, 세션 전체를 더하면 다른 task 의 턴이
+    # 섞인다. 창 안에서 활동한 세션을 후보에 넣고 토큰은 창으로 잘라 센다.
+    window = (run_since, run_until)
+    if provider == "codex":
+        candidates = find_codex_sessions(
+            project_root, run_since, run_until, active_before_start=True,
+        )
+    else:
+        candidates = find_grok_sessions(
+            project_root, run_since, run_until, active_before_start=True,
+        )
     sessions = _select_cli_lead_sessions(
         provider,
-        [
-            path
-            for path in _cli_sessions_for_windows(
-                provider, project_root, [(run_since, run_until)],
-            )
-            if path not in worker_paths
-        ],
+        [path for path in candidates if path not in worker_paths],
         state,
+        window=window,
     )
-    totals = _cli_session_totals(provider, sessions)
+    totals = _cli_session_totals(provider, sessions, window=window)
     if not totals:
         return na_block(
             f"{provider} lead usage accounting is unavailable because no host session "
-            "started in the run window."
+            "was active in the run window."
         )
     return _cli_usage_block(provider, _aggregate_totals(totals), sessions)
 
@@ -981,7 +1139,11 @@ def _cli_worker_session(provider: str, path: Path) -> bool:
 
 
 def _select_cli_lead_sessions(
-    provider: str, sessions: list[Path], state: dict,
+    provider: str,
+    sessions: list[Path],
+    state: dict,
+    *,
+    window: tuple[str, str] | None = None,
 ) -> list[Path]:
     """워커 래퍼 세션을 빼고, 아이디가 있으면 그 세션, 없으면 벽시계가 가장 긴 대화."""
     candidates = [
@@ -997,7 +1159,7 @@ def _select_cli_lead_sessions(
     best = candidates[0]
     best_ms = -1
     for path in candidates:
-        totals = _cli_session_totals(provider, [path])
+        totals = _cli_session_totals(provider, [path], window=window)
         total = totals[0] if totals else {}
         wall = _wall_ms(total.get("startedAt"), total.get("endedAt")) if total else None
         if wall is None:
@@ -1056,14 +1218,22 @@ def _populate_usage_summary(
         worker_cost += unattributed_usage.get("estimatedCostUsd", 0) or 0
 
     unmatched_models: list[str] = []
-    if lead.get("model") and lead.get("estimatedCostUsd") is None and (lead.get("totalTokens") or 0) > 0:
+    if (
+        lead.get("model")
+        and lead.get("estimatedCostUsd") is None
+        and lead.get("cliEstimatedCostUsd") is None
+        and (lead.get("totalTokens") or 0) > 0
+    ):
         unmatched_models.append(lead["model"])
     for w in workers:
         u = w.get("usage") or {}
+        # CLI 블록의 가격은 `cliEstimatedCostUsd` 에 붙는다 — 그 키를 안 보면
+        # 가격이 붙은 grok 도 미매칭으로 찍힌다.
         if (
             u.get("source") not in {"codex-cli", "agy-cli"}
             and u.get("model")
             and u.get("estimatedCostUsd") is None
+            and u.get("cliEstimatedCostUsd") is None
             and (u.get("totalTokens") or 0) > 0
         ):
             unmatched_models.append(u["model"])
@@ -1269,6 +1439,12 @@ def collect_claude_runtime_usage(
                     provider=provider,
                     project_root=cwd,
                     worker=worker,
+                    records=[
+                        dict(record)
+                        for record in worker_dispatch_records(
+                            state, str(worker_id or "").strip()
+                        )
+                    ] if worker_id else [],
                     fallback_windows=cli_windows_by_worker.get(
                         str(worker_id or "").strip(), []
                     ),
@@ -1363,7 +1539,9 @@ def collect_cli_runtime_usage(
 ) -> dict:
     state = json.loads(team_state_path.read_text())
     cwd = project_root or _infer_project_root(team_state_path, state)
-    return _collect_cli_runtime_usage(state, cwd, team_state_path)
+    return _collect_cli_runtime_usage(
+        state, cwd, team_state_path, incremental=incremental,
+    )
 
 
 def collect(

package/runtime/python/okstra_token_usage/grok.py

@@ -1,8 +1,12 @@
 """Grok Build session collectors.
 
 공식 세션 문서는 대화를 ``~/.grok/sessions/`` 에 둔다. cwd 는 퍼센트 인코딩된
-디렉터리 이름이다. 누적 사용량은 ``updates.jsonl`` 의
-``params.update.usage.modelUsage`` 마지막 스냅샷이다.
+디렉터리 이름이다. ``updates.jsonl`` 의 ``params.update.usage`` 행 하나는
+**프롬프트 한 번**의 사용량이다 — ``numTurns`` 는 그 프롬프트 안의 모델 호출
+수이고 ``inputTokens`` 는 매번 컨텍스트 전체라 값이 오르내린다(실측
+2026-09-08, 대화형 세션 3개 39행: 83k → 798k → 406k → 187k …). 세션 합계는
+행의 합이고, 마지막 행은 마지막 프롬프트일 뿐이다. exec 래퍼 워커는 프롬프트가
+하나라 행도 하나다.
 """
 from __future__ import annotations
 
@@ -53,39 +57,55 @@ def _model_snapshot(usage: dict) -> tuple[dict, str | None]:
     return usage, None
 
 
-def grok_session_total(updates_path: Path) -> dict:
-    """마지막 modelUsage 스냅샷. 세션 누적이라 더하지 않는다."""
-    last: dict | None = None
+_SUM_KEYS = (
+    ("totalTokens", "totalTokens"),
+    ("inputTokens", "inputTokens"),
+    ("outputTokens", "outputTokens"),
+    ("cachedInputTokens", "cachedReadTokens"),
+    ("reasoningOutputTokens", "reasoningTokens"),
+    ("durationMs", "apiDurationMs"),
+)
+
+
+def grok_session_window_total(
+    updates_path: Path, since: str | None = None, until: str | None = None,
+) -> dict:
+    """창 안 usage 행의 합. 창이 없으면 세션 전체.
+
+    한 행이 프롬프트 한 번의 사용량이므로 더한다 — 마지막 행만 읽으면 여러
+    프롬프트를 돌린 세션(in-session 리드)은 마지막 프롬프트만 남는다. 창은
+    run 보다 먼저 열린 리드 세션에서 다른 task 의 프롬프트를 걸러 낸다.
+    """
+    sums = {name: 0 for name, _raw in _SUM_KEYS}
     model: str | None = None
     started: str | None = None
     ended: str | None = None
+    counted = 0
     for record in iter_jsonl(updates_path):
         usage = _usage_payload(record)
         if usage is None:
             continue
         iso = _iso_from_unix(record.get("timestamp"))
+        if iso and not ts_in_window(iso, since, until):
+            continue
+        snapshot, snapshot_model = _model_snapshot(usage)
+        for name, raw in _SUM_KEYS:
+            sums[name] += snapshot.get(raw, 0) or 0
+        if snapshot_model:
+            model = snapshot_model
         if iso and started is None:
             started = iso
         if iso:
             ended = iso
-        snapshot, snapshot_model = _model_snapshot(usage)
-        last = snapshot
-        if snapshot_model:
-            model = snapshot_model
-    if last is None:
+        counted += 1
+    if not counted:
         return {"totalTokens": 0, "available": False}
-    return {
-        "totalTokens": last.get("totalTokens", 0) or 0,
-        "inputTokens": last.get("inputTokens", 0) or 0,
-        "outputTokens": last.get("outputTokens", 0) or 0,
-        "cachedInputTokens": last.get("cachedReadTokens", 0) or 0,
-        "reasoningOutputTokens": last.get("reasoningTokens", 0) or 0,
-        "durationMs": last.get("apiDurationMs", 0) or 0,
-        "model": model,
-        "startedAt": started,
-        "endedAt": ended,
-        "available": True,
-    }
+    return {**sums, "model": model, "startedAt": started, "endedAt": ended, "available": True}
+
+
+def grok_session_total(updates_path: Path) -> dict:
+    """세션 전체 — 모든 usage 행의 합."""
+    return grok_session_window_total(updates_path)
 
 
 def _session_started_in_window(
@@ -102,14 +122,38 @@ def _session_started_in_window(
     return False
 
 
+def _session_active_in_window(
+    updates_path: Path, started_at: str, ended_at: str,
+) -> bool:
+    """창보다 먼저 열렸지만 창 안에도 usage 행이 있는 세션 — in-session 리드."""
+    first: str | None = None
+    for record in iter_jsonl(updates_path):
+        iso = _iso_from_unix(record.get("timestamp"))
+        if not iso:
+            continue
+        if first is None:
+            first = iso
+            if not ts_in_window(first, None, started_at):
+                return False
+        if ts_in_window(iso, started_at, ended_at):
+            return True
+    return False
+
+
 def find_grok_sessions(
     cwd: Path,
     started_at: str,
     ended_at: str,
     *,
     session_root: Path | None = None,
+    active_before_start: bool = False,
 ) -> list[Path]:
-    """cwd 로 인코딩된 세션 중 창 안에서 시작된 updates.jsonl."""
+    """cwd 로 인코딩된 세션 중 창 안에서 시작된 updates.jsonl.
+
+    `active_before_start=True` 는 창보다 먼저 시작했지만 창 안에서도 프롬프트를
+    돌린 세션을 더한다 — in-session 리드의 모양이고, 토큰은
+    `grok_session_window_total` 이 창으로 잘라 센다.
+    """
     if not started_at or not ended_at:
         return []
     root = session_root or grok_sessions_root()
@@ -125,8 +169,11 @@ def find_grok_sessions(
             continue
         for session in child.iterdir():
             updates = session / "updates.jsonl"
-            if updates.is_file() and _session_started_in_window(
-                updates, started_at, ended_at
+            if not updates.is_file():
+                continue
+            if _session_started_in_window(updates, started_at, ended_at) or (
+                active_before_start
+                and _session_active_in_window(updates, started_at, ended_at)
             ):
                 matches.append(updates)
     return sorted(matches)

package/runtime/python/okstra_token_usage/pricing.py

@@ -59,8 +59,12 @@ CLAUDE_PRICING = {
     # Claude Opus 5.
     "opus-5":     (5.0, 6.25, 0.50, 25.0),     # Opus 5 (cache prices derived from ratios)
 
-    # Claude Sonnet 5.
-    "sonnet-5":   (3.0, 3.75, 0.30, 15.0),     # Sonnet 5 (cache prices derived from ratios)
+    # Claude Sonnet 5 — $2/$10 launched as introductory pricing and became the
+    # standard price (the announced 2026-09-01 rise to $3/$15 was withdrawn;
+    # platform.claude.com/docs/en/about-claude/pricing, read 2026-09-08). The
+    # old (3.0, 3.75, 0.30, 15.0) row was the Sonnet 4.6 rate and overbilled
+    # every Sonnet 5 worker by 1.5x.
+    "sonnet-5":   (2.0, 2.50, 0.20, 10.0),     # Sonnet 5 (cache prices derived from ratios)
 
     # Claude 4 point releases (explicit so future divergence is easy to see).
     "opus-4-8":   (5.0, 6.25, 0.50, 25.0),     # Opus 4.8 (cache prices derived from ratios)
@@ -90,8 +94,8 @@ _LEGACY_CODEX_PRICING = {
 
     # GPT-5 series.
     # gpt-5.6 was dropped from the provider catalog; its rate stays so past runs
-    # keep pricing. Substring matching means sol / terra / luna resolve here too
-    # -- the 5.6 family rate, not a per-variant price we have a source for.
+    # keep pricing. sol / terra / luna no longer land here: their catalog rows
+    # carry per-variant prices, and `_match_pricing` prefers the longer key.
     "gpt-5.6":      (5.00,  0.50,  30.0),
     "gpt-5.2-pro":  (21.0,  2.10,  168.0),
     "gpt-5.1":      (1.25,  0.125, 10.0),

package/runtime/skills/okstra-run/SKILL.md

@@ -41,7 +41,7 @@ Every non-terminal `next` carries a `progress` object (`done` / `aborted` omit i
 
 On `ok: false`, re-prompt with the same `current.step` using the error message. The wizard never advances on validation failure; the user retries the same step. **`current` may be `null`** when the current step itself cannot render (e.g. the approved plan's Stage Map is corrupt) — that case is terminal: show `error` and stop, the user must fix the plan file before retrying. Never re-prompt off a `null` `current`.
 
-The wizard tells you which relay operation to use via `next.interaction.kind`. Step 1 loads the current registered host's relay contract. Use the matching entry under its `interactions` object exactly; if the entry is absent, stop instead of inventing a host function or falling back silently. The only exception is the explicit `Legacy text relay compatibility` mapping selected in Step 1 when the preflight response has no `relayContract`.
+The wizard tells you which relay operation to use via `next.interaction.kind`. Step 1 loads the current registered host's relay contract. Use the matching entry under its `interactions` object, including the runtime-generated navigation and completion options. If the entry is absent, stop instead of inventing a host function or falling back silently. Use the explicit `Legacy text relay compatibility` mapping only when the preflight response has no `relayContract`.
 
 - `native-single` → use the current registered host's relay contract for its native single-select function. Pass every option in its original order and submit the selected `options[].value`.
 - `native-multi` → use the relay contract's native multi-select function. Pass every option in its original order and submit the selected values as one CSV answer; submit an empty selection as `--answer ""`.
@@ -53,7 +53,9 @@ The wizard tells you which relay operation to use via `next.interaction.kind`. S
 - `kind: "done"` → input collection finished; move to Step 5.
 - `kind: "aborted"` → the user picked abort; the wizard is terminally cancelled. Tell the user on one short line that the run setup was aborted, delete the state file (`rm` with the literal path), and stop this skill — do NOT call `render-args` or `render-bundle` (the wizard rejects `render-args` on an aborted state).
 
-Submit the answer shape required by `interaction.answerProtocol`; do not add normalization that the protocol does not request. Invalid, out-of-range, or ambiguous answers return `ok: false` and must re-render the same complete interaction.
+When native single selection is available, the runtime divides long lists and unsupported multi-selections into selectable screens. Render the returned screen without rebuilding the full list. This applies to plan confirmation, stages, role counts, and provider/model lists. Submit navigation and completion option values normally; the runtime retains the current step until its answer is complete. A ban on textual choice lists does not authorize asking the user to type a model identifier. If a required selector is unavailable, preserve state and follow the relay's recovery. Genuine text steps still collect text.
+
+Submit the answer shape required by `interaction.answerProtocol`; do not add normalization beyond the registered relay's explicit mapping. Invalid, out-of-range, or ambiguous answers return `ok: false` and must re-render the same complete interaction.
 
 The final `confirm` step is a normal `pick` step with three options — `Proceed` / `Edit` / `Abort`(abort) — and is rendered the same way (no special handling). `Edit` rewinds to any earlier step (including `base-ref`); `Abort` terminally cancels the wizard. The branch/worktree decision the run will actually use (for `implementation`, the **stage worktree** — not the task-key directory) is folded into the Step 4 confirmation summary block as a `worktree` line, so there is no separate branch-confirm prompt.
 
@@ -87,6 +89,8 @@ If the successful fixed projection has `Relay contract: -`, enter the compatibil
 
 Before calculating the effective intersection, apply the registered relay's client-specific tool selection and live mode restrictions. A callable question tool does not necessarily render a selector in the current client. In Codex, use the synchronous picker when permitted; asynchronous question cards are a desktop fallback, not a terminal picker. If the user requires a selectable interface and the current client cannot provide it, preserve the wizard state and follow the relay's recovery instead of printing the option list.
 
+Plan adoption (`approve_plan_confirm`) is a workflow choice: present the wizard's existing options using the same selector as other `pick` steps. Follow the relay's distinction between plan decisions and execution permissions; the word "approval" alone is not a reason to replace a selector with a typed confirmation.
+
 ### Legacy text relay compatibility
 
 Use this built-in mapping only when the successful preflight response omitted `relayContract`. It is not a fallback for an unreadable, malformed, mismatched, or incomplete relay contract. If a present relay contract omits the wizard's interaction kind, keep the fail-closed rule above and stop.

package/runtime/validators/validate-run.py

@@ -569,7 +569,12 @@ def _validate_agent_dispatch_contract(
         dispatch_id = str(link.get("dispatchId") or "").strip()
         result_path = str(link.get("resultPath") or "").strip()
         if dispatch_id not in ids or not result_path:
-            failures.append("agent result link has no matching dispatch record")
+            # 같은 문장이 링크 수만큼 반복되면 어느 링크인지 알 수 없다 — 대상을 이름한다.
+            failures.append(
+                "agent result link has no matching dispatch record: "
+                f"dispatchId={dispatch_id or '<empty>'} "
+                f"resultPath={Path(result_path).name if result_path else '<empty>'}"
+            )
             continue
         if uses_v2_identity:
             dispatch = ids[dispatch_id]