okstra 0.190.0 → 0.191.0

package/docs/architecture.md

@@ -937,11 +937,15 @@ Tokens used in each run are collected from lead/worker session transcripts and w
 - Helper CLI: `scripts/okstra-token-usage.py`
 - Collection sources:
   - Claude lead/workers: per-message `message.usage` in `~/.claude/projects/<cwd-as-dashes>/<sessionId>.jsonl` or `~/.claude/projects/<cwd-as-dashes>/<lead-session>/subagents/agent-a<worker-name>-<hash>.jsonl`. Worker names are recovered from nested-subagent filenames, and only the directory for the current run's `team-state.lead.sessionId` is counted.
-  - Codex CLI: final `total_token_usage.total_tokens` in `~/.agent/sessions/Y/M/D/rollout-*.jsonl`
+  - Codex CLI: final `total_token_usage.total_tokens` in `~/.codex/sessions/Y/M/D/rollout-*.jsonl` (`$CODEX_HOME/sessions` first, then `~/.agent/sessions`). An in-session codex lead (`entryMode: current-session`) opened its rollout before the run and keeps it after, so its cumulative snapshot is the whole session; the lead is counted as the sum of `last_token_usage` over the `token_count` events inside the run window (`codex_session_window_total`), and a session that started before the window still qualifies when it wrote inside it (`find_codex_sessions(active_before_start=True)`).
+  - Grok CLI: the last `usage` snapshot in `~/.grok/sessions/<percent-encoded cwd>/<sessionId>/updates.jsonl`. grok (and kimi) run *inside* the stage worktree, so the directory is encoded from the worktree path, not the project root.
+  - Claude workers on a non-Claude host: the wrapper runs `claude -p --session-id <id>`, and the transcript is `~/.claude/projects/<cwd-as-dashes>/<id>.jsonl`, found by the id `workerDispatches[].sessionId` recorded at dispatch.
+- **Attribution key is the dispatch ledger, not the roster row.** `workers[].promptPath` names one prompt — the first dispatch — and v2 lead events carry no `workerId`. Every re-dispatch (reverify, critic-gap, plan-verify, report-writer re-author) is a new wrapper run with its own prompt, `.status.json`, and transcript, and only `team-state.workerDispatches[]` lists them all (`dispatch_state.worker_dispatch_records`, keyed by `workerId` or the last segment of `assignmentRef`). The collector takes one wrapper window per record, unions the transcripts found under each record's `worktreePath` and the project root, and sums them; wall-clock is the sum of the wrapper windows. Observed before this rule (2026-09-08, a codex-host planning run): codex counted 1 of 5 sessions, grok 0 of 1, claude 0 of 7.
   - Antigravity CLI: the `usage` snapshot in the wrapper `<prompt>.status.json` — the runner records the last `usage` the `agy` stream reported (`result.usage` on a run that closed). The CLI writes no transcript under the home directory, and the worker `.log` is the stream rewritten as readable lines, not stream-json.
 - CLI execution evidence and token attribution are independent. A wrapper `.status.json` proves `not-started`, `started`, `exited`, `timeout`, or `failed` and supplies the worker's collection window; only a matching transcript with a final token snapshot — or, for a provider without a home transcript, the `usage` snapshot the runner wrote into that `.status.json` — proves attributable usage. If a wrapper exited successfully but no attributable transcript exists, the worker remains `source: "unavailable"` with `cliExecutionStatus: "exited"` and a reason instead of becoming zero usage or being described as never invoked.
 - Records billable-equivalent token math and USD cost estimates. It applies Anthropic billing ratios (`cache_creation_5m=1.25x`, `cache_creation_1h=2.0x`, `cache_read=0.1x`, `output=5x`). When the transcript provides separate `usage.cache_creation.ephemeral_5m_input_tokens` / `ephemeral_1h_input_tokens` values, they are counted separately.
-- Pricing is centrally managed in `scripts/okstra_token_usage/pricing.py`. Update it when model prices change. Model IDs that fail price matching are exposed to the user in `usageSummary.unmatchedModels`, preventing silent-zero incidents.
+- Pricing is centrally managed in `scripts/okstra_token_usage/pricing.py` (Claude and Gemini rate tables) and in each provider catalog's `ModelSpec(pricing=...)` (codex, grok, kimi — merged through `catalog_pricing`). Update it when model prices change. Model IDs that fail price matching are exposed to the user in `usageSummary.unmatchedModels`, preventing silent-zero incidents.
+- **Cost is always the public list price, regardless of how the account is billed.** The report answers "how much was consumed", not "what the invoice says": a model served under a ChatGPT/Claude subscription is still priced at its API rate, so every selectable catalog row must carry a price. The one row without a price is `codex-auto-review`, for which no public rate exists.
 - Project-wide historical usage is exposed through the read-only `okstra usage-report` command (`scripts/okstra_ctl/usage_report.py`) and the `okstra-usage` skill. It defaults to the whole current project's last 30 days and returns run coverage, raw and billable-equivalent tokens, known USD cost, CPU-sum milliseconds, and wall-clock milliseconds grouped by task type. Runs without usable Phase 7 usage are excluded from resource totals and reported through unavailable reason counts rather than treated as zero usage; unmatched model names remain visible when their tokens and time are included but their cost is not. Use `okstra-inspect` for one task's elapsed/context detail and `okstra-rollup` for task-group or project status/report digests.
 - **Incremental scan cache (P6)**: To avoid rescanning session jsonl files, a per-file byte cursor and the extracted usage events before windowing are stored in `$OKSTRA_HOME/cache/token-usage/<transcript-dir>/<sessionId>.json` (`scripts/okstra_token_usage/cursor.py`). The run window (since/until) is reevaluated over events on every invocation, so even if a rerun narrows the window, the total matches a full scan. The cache is derived data; identifier mismatch, truncation, or corruption automatically falls back to a full rescan, and `okstra-token-usage.py --no-cache` forces a bypass.
 - **Phase timeline (P0 instrumentation)**: The collector extracts `PROGRESS: phase-*` checkpoint lines (see "Progress reporting" in prompts/lead/okstra-lead-contract.md) from the lead session jsonl scoped to the run window, and records them in team-state as a `phaseTimeline` block (`{source, phases: [{phase, firstAt, lastAt, markerCount, wallMsToNext}]}`) (`scripts/okstra_token_usage/collect.py :: phase_timeline`). This provides measurement points for per-phase wall-clock time within the run and is consumed by the "Per-run phase breakdown" in the `okstra-inspect` time facet. Runs without markers explicitly report that measurement is unavailable with `phases: []`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.190.0",
+  "version": "0.191.0",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.190.0",
-  "builtAt": "2026-09-08T19:21:43.911Z",
+  "package": "0.191.0",
+  "builtAt": "2026-09-08T21:03:17.927Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/python/okstra_ctl/adapters/hosts/codex/relay.md

@@ -115,11 +115,25 @@ For `request_user_input`, send one to three questions. Each question carries `id
 For a `host-text` mapping, render each numbered item as its option label followed by its description verbatim; preserve every item and its order. The next user message is the raw answer: do not translate a number such as `1`, a CSV reply such as `1, 3`, an option label, or an option value before `okstra wizard step`. For `sequential-group`, collect one raw reply per question in order and build one compact JSON object keyed by the corresponding `questions[].step`; the wizard owns all normalization.
 
 
+### Runtime-generated selectable screens
+
+`wizard/engine.py` adapts choice screens before returning `next` when the session declares `native_single_select`. `wizard/picker_navigation.py` preserves all original choices while paging long lists, collecting multi-selection through toggle/complete choices, and disambiguating duplicate labels. Oversized or unsupported groups are presented one member at a time. These paths are exercised by `tests/domain/wizard/test_picker_navigation.py` and `test_role_model_selection.py`.
+
+Render exactly the returned current screen using its `interaction.kind`, including navigation and completion options. Submit their original values through `okstra wizard step` like other options. The runtime keeps navigation and partial selections in the state file and does not submit the underlying workflow decision until selection is complete. Do not reconstruct the full model list, perform pagination yourself, or replace model choices with a request to type `provider/model`. A repeated step ID after navigation or a toggle is the next screen, not a duplicated question; render that newly returned screen once.
+
+If the runtime still returns a numbered interaction when the user requires a selector, preserve the state and check installation and live capabilities. Do not invent a text-input exception. Text steps remain text steps; a direct-input choice is selected through the picker before the runtime asks for the custom value.
+
+### Plan decisions and execution permissions
+
+Classify the requested action, not the word "approval". The wizard's `approve_plan_confirm` is a workflow decision about adopting the selected plan; it is a `pick` prompt built by `_build_approve_plan_confirm` in `wizard/steps_plan.py`. Render its existing options through the available native selector, just like task type and plan selection. Explain the effect of each option in the question tool and map the selected label back to its original value (`yes`, `no`, or `yes_apply` when offered). Recording that decision in okstra artifacts does not turn the question into a host permission request. Do not ask the user to type an approval word or switch to prose merely because this step is called approval.
+
+Host permission requests concern execution privileges, sandbox escalation, or access to a protected resource. Use the host's permission mechanism for those requests; a wizard answer does not grant those privileges. If a subsequent command requires such permission, handle it separately at that command.
+
 ### Client-aware question tool selection
 
 Before intersecting `semanticFunctions` with live capabilities, prefer `request_user_input` when the current session permits that call. Use its live restrictions rather than assuming it is always Plan-only: Codex CLI can enable it in Default mode with `default_mode_request_user_input`. The JSON mapping above remains the terminal picker contract.
 
-Use `request_user_input_async` only when the current client explicitly supports interactive asynchronous question cards, such as the Codex desktop app, and the synchronous tool is unavailable. Callable does not mean selectable: the Codex terminal (`codex-tui`, session source `cli`) can accept an asynchronous question but render it as a plain bulleted agent message. Do not count that terminal delivery as `native_single_select` or `native_question_group`. For a supported desktop client, replace the `function` of both native entries above with `request_user_input_async` and use the mapping below. Keep the conservative `nativeLimits` and the numbered mapping for multi-selection.
+Use `request_user_input_async` only when the current client explicitly supports interactive asynchronous question cards, such as the Codex desktop app, and the synchronous tool is unavailable. Callable does not mean selectable: the Codex terminal (`codex-tui`, session source `cli`) can accept an asynchronous question but render it as a plain bulleted agent message. Do not count that terminal delivery as `native_single_select` or `native_question_group`. For a supported desktop client, replace the `function` of both native entries above with `request_user_input_async` and use the mapping below. Keep the declared `nativeLimits`; the runtime generates the selectable screens within those limits.
 
 If the user requested a selectable interface in the terminal and `request_user_input` is unavailable, keep the current wizard step pending instead of printing its options. `okstra install` enables `features.default_mode_request_user_input` when a Codex home exists, through `ensureCodexQuestionPicker` in `src/lib/host-config.mts`. Restart or resume the Codex session after installation and reread this relay. Changing the feature does not replace the current session's tool catalog. Preserve the existing wizard state-file path and call `okstra wizard step --state-file <existing-path> --no-submit` after resuming; do not initialize a replacement wizard or submit a guessed answer. If installation reports a configuration shape it cannot safely edit, its recovery command is `codex features enable default_mode_request_user_input`. Apply a configuration change only when authorized by the user, otherwise present the recovery command. The feature's availability is reported by `codex features list`; older clients without it need a client update or a mode in which the synchronous tool is permitted.
 

package/runtime/python/okstra_ctl/adapters/providers/codex/adapter.py

@@ -21,11 +21,17 @@ import okstra_ctl.model_discovery as model_discovery
 # `gpt-5.6` is not a slug that catalog offers at all, so it is gone from here;
 # its rate moved to `_LEGACY_CODEX_PRICING` so past runs still price.
 CODEX = {
-    # ChatGPT-account hosts serve these models without per-token billing.
-    "gpt-6-astra": ModelSpec("gpt-6-astra", "gpt-6-astra", "gpt-6-astra"),
-    "gpt-5.6-sol": ModelSpec("gpt-5.6-sol", "gpt-5.6-sol", "gpt-5.6-sol"),
-    "gpt-5.6-terra": ModelSpec("gpt-5.6-terra", "gpt-5.6-terra", "gpt-5.6-terra"),
-    "gpt-5.6-luna": ModelSpec("gpt-5.6-luna", "gpt-5.6-luna", "gpt-5.6-luna"),
+    # 비용은 계정이 구독이든 API 든 공개 API 단가(입력·캐시 입력·출력 USD/1M)로
+    # 추정한다 — 리포트가 답하는 것은 "얼마나 썼는가" 이지 "청구서에 얼마가
+    # 찍히는가" 가 아니다. 단가를 비우면 그 워커의 비용이 `--` 로 빠지고, 접두어
+    # 폴백(`_LEGACY_CODEX_PRICING`)에 걸리면 terra·luna 가 sol 단가로 과대
+    # 계상된다(실측 2026-09-08). 출처: OpenAI 표준 등급, 2026-09 기준
+    # (morphllm.com/openai-api-pricing, cloudzero.com/blog/openai-pricing,
+    # layer3labs.io/guides/gpt-6-astra-api-pricing).
+    "gpt-6-astra": ModelSpec("gpt-6-astra", "gpt-6-astra", "gpt-6-astra", pricing=(10.0, 1.0, 50.0)),
+    "gpt-5.6-sol": ModelSpec("gpt-5.6-sol", "gpt-5.6-sol", "gpt-5.6-sol", pricing=(5.0, 0.50, 30.0)),
+    "gpt-5.6-terra": ModelSpec("gpt-5.6-terra", "gpt-5.6-terra", "gpt-5.6-terra", pricing=(2.0, 0.20, 12.0)),
+    "gpt-5.6-luna": ModelSpec("gpt-5.6-luna", "gpt-5.6-luna", "gpt-5.6-luna", pricing=(0.20, 0.02, 1.20)),
     # picker 에서는 감춘다. 엔트리는 남긴다 — 과거 run 의 토큰 사용량을
     # 정산할 때 pricing 을 이 표에서 찾는다.
     "gpt-5.4-mini": ModelSpec("gpt-5.4-mini", "gpt-5.4-mini", "gpt-5.4-mini", pricing=(0.75, 0.075, 4.50), selectable=False),

package/runtime/python/okstra_ctl/adapters/providers/kimi/adapter.py

@@ -19,9 +19,12 @@ from okstra_ctl.domain.worker_stream import content_block_events
 KIMI = {
     "kimi-k3": ModelSpec("kimi-k3", "Kimi K3", "kimi-k3", aliases=("kimi k3",), pricing=(3.00, 0.30, 15.00)),
     # picker 에서는 감춘다: kimi-k3 와 표시명·실체가 같아 목록에 두 줄로 뜬다.
-    "k3": ModelSpec("k3", "Kimi K3", "k3", selectable=False),
+    # 단가는 kimi-k3 와 같다 — 같은 모델의 다른 슬러그이고, `_match_pricing` 은
+    # `kimi-k3` 키를 `k3` 관측값에 맞추지 못하므로 행마다 값을 둔다. k3-256k 는
+    # Moonshot 이 별도 단가를 공개하지 않아 K3 단가를 쓴다(2026-09-08 확인).
+    "k3": ModelSpec("k3", "Kimi K3", "k3", pricing=(3.00, 0.30, 15.00), selectable=False),
     # picker 에서는 감춘다(사유는 codex 의 gpt-5.4-mini 와 동일).
-    "k3-256k": ModelSpec("k3-256k", "Kimi K3 256K", "k3-256k", aliases=("kimi k3 256k",), selectable=False),
+    "k3-256k": ModelSpec("k3-256k", "Kimi K3 256K", "k3-256k", aliases=("kimi k3 256k",), pricing=(3.00, 0.30, 15.00), selectable=False),
 }
 
 

package/runtime/python/okstra_ctl/dispatch_state.py

@@ -1692,16 +1692,39 @@ def worker_session_ids(
     here, the same way `add_observed_session` keeps it for the keys it appends to.
     """
     session_ids: list[str] = []
+    for record in worker_dispatch_records(team_state, worker_id):
+        session_id = str(record.get("sessionId") or "").strip()
+        if session_id and session_id not in session_ids:
+            session_ids.append(session_id)
+    return session_ids
+
+
+def worker_dispatch_records(
+    team_state: Mapping[str, Any], worker_id: str | None = None
+) -> list[Mapping[str, Any]]:
+    """한 워커(또는 run 전체)의 `workerDispatches[]` 행을 기록된 순서대로.
+
+    사용량 수집이 워커의 실행 증거를 찾는 열쇠는 이 행들이다 — 프롬프트 경로
+    (status 사이드카 → 래퍼 창), 세션 id(claude 트랜스크립트), 워크트리 경로
+    (grok·kimi 는 그 안에서 돌아 세션 디렉터리가 그 경로로 인코딩된다).
+    `workers[]` 행의 `promptPath` 는 첫 dispatch 하나만 가리키므로 재검증·
+    critic-gap·plan-verify 로 다시 띄운 세션은 거기서 보이지 않는다(실측
+    2026-09-08 jobs implementation-planning r01: codex 5회 dispatch 중 1회만
+    집계, v2 명부 행 `scope` 는 `promptPath` 가 비어 0회).
+
+    v1 행은 `workerId`, v2 행은 `assignmentRef` 마지막 마디로 워커에 묶인다
+    (`_dispatch_worker_key`). 리스트가 아니면 빈 결과 — `worker_session_ids`
+    와 같은 이유로 호출자를 깨지 않는다.
+    """
     dispatches = team_state.get("workerDispatches")
+    records: list[Mapping[str, Any]] = []
     for record in dispatches if isinstance(dispatches, list) else []:
         if not isinstance(record, Mapping):
             continue
         if worker_id is not None and _dispatch_worker_key(record) != worker_id:
             continue
-        session_id = str(record.get("sessionId") or "").strip()
-        if session_id and session_id not in session_ids:
-            session_ids.append(session_id)
-    return session_ids
+        records.append(record)
+    return records
 
 
 def _dispatch_worker_key(record: Mapping[str, Any]) -> str:

package/runtime/python/okstra_ctl/wizard/engine.py

@@ -33,6 +33,7 @@ from .ids import (
 )
 from .state import Prompt, WizardError, WizardState, _is_role_selection_step
 from .prompts import _domain_prompt
+from .picker_navigation import present_picker, accept_picker_answer
 from .roles import _submit_role_prompt, next_role_prompt
 from .steps_identity import _submit_task_pick
 from .steps_analysis import _advance_design_prep_item
@@ -125,11 +126,24 @@ def next_prompt(state: WizardState) -> Prompt:
     for _ in range(len(STEPS)):
         prompt = _next_prompt_screen(state)
         if not _is_lone_free_input_pick(prompt):
-            return prompt
+            return _native_picker_screen(state, prompt)
         _take_free_input_branch(state, prompt)
     return _next_prompt_screen(state)
 
 
+def _native_picker_screen(state: WizardState, prompt: Prompt) -> Prompt:
+    if "native_single_select" not in state.available_functions:
+        return prompt
+    if prompt.kind == "pick_group":
+        if _interaction_plan(state, prompt).kind == "native-group":
+            return prompt
+        prompt = prompt.questions[0]
+    if _interaction_plan(state, prompt).kind == "native-multi":
+        return prompt
+    limit = default_host_registry().resolve(state.host_runtime).interaction().native_option_limit
+    return present_picker(state, prompt, limit=limit)
+
+
 def _next_prompt_screen(state: WizardState) -> Prompt:
     if state.aborted:
         return Prompt(step=S_ABORTED, kind="aborted")
@@ -345,6 +359,13 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
         return {"echo": "", "next": prompt_payload(state, prompt)}
     plan = _interaction_plan(state, prompt)
     value = _normalize_interaction_answer(state, prompt, plan, value)
+    if plan.kind == "native-single":
+        original = _next_prompt_screen(state)
+        if original.kind == "pick_group":
+            original = next(q for q in original.questions if q.step == prompt.step)
+        value = accept_picker_answer(state, original, value)
+        if value is None:
+            return {"echo": "", "next": prompt_payload(state, next_prompt(state))}
     if prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
     if _is_role_selection_step(prompt.step):

package/runtime/python/okstra_ctl/wizard/picker_navigation.py

@@ -0,0 +1,75 @@
+"""호스트 선택기 한도 안에서 원래 선택지를 보존하는 화면 변환."""
+from dataclasses import replace
+
+from okstra_ctl.wizard_stage_intent import WHOLE_TASK_STAGE
+
+from .ids import ALL_STAGES, PICK_TYPE_CUSTOM
+from .state import Option, Prompt, WizardError, WizardState
+
+_PAGE_PREFIX = "__okstra_picker_page__:"
+_DONE = "__okstra_picker_done__"
+
+
+def present_picker(state: WizardState, prompt: Prompt, *, limit: int) -> Prompt:
+    if prompt.kind != "pick" or not prompt.options:
+        return prompt
+    selected = state.picker_selected.get(prompt.step, [])
+    labels = [option.label for option in prompt.options]
+    options = [replace(
+        option,
+        label=("✓ " if option.value in selected else "") + option.label
+        + (f" [{option.value}]" if labels.count(option.label) > 1 else ""),
+    ) for option in prompt.options]
+    reserve = 2 if prompt.multi else 1
+    paged = len(options) + int(prompt.multi) > limit
+    size = max(1, limit - reserve) if paged else len(options)
+    offset = state.picker_offsets.get(prompt.step, 0)
+    offset = offset if 0 <= offset < len(options) else 0
+    shown = options[offset:offset + size]
+    label = prompt.label
+    if paged:
+        next_offset = offset + size if offset + size < len(options) else 0
+        shown.append(Option(
+            f"{_PAGE_PREFIX}{next_offset}",
+            "다음 선택지" if next_offset else "처음 선택지로",
+        ))
+        label += f" ({offset + 1}–{min(offset + size, len(options))}/{len(options)})"
+    if prompt.multi:
+        shown.append(Option(_DONE, f"선택 완료 ({len(selected)}개)"))
+        label += " · 항목을 선택하면 선택/해제됩니다. 완료를 누르면 제출합니다."
+    if len(shown) == 1:
+        shown.append(Option(f"{_PAGE_PREFIX}0", "다시 보기"))
+    shown = [o for o in shown if o.value != PICK_TYPE_CUSTOM] + [
+        o for o in shown if o.value == PICK_TYPE_CUSTOM
+    ]
+    return replace(prompt, label=label, options=shown, multi=False)
+
+
+def accept_picker_answer(state: WizardState, prompt: Prompt, value: str) -> str | None:
+    if value.startswith(_PAGE_PREFIX):
+        raw_offset = value.removeprefix(_PAGE_PREFIX)
+        if not raw_offset.isdecimal() or not 0 <= int(raw_offset) < len(prompt.options):
+            raise WizardError("invalid picker page; select a returned navigation option")
+        state.picker_offsets[prompt.step] = int(raw_offset)
+        return None
+    if not prompt.multi:
+        state.picker_offsets.pop(prompt.step, None)
+        return value
+    if value != _DONE and value not in {o.value for o in prompt.options}:
+        raise WizardError("invalid picker choice; select an option from the current screen")
+    if value in {_DONE, PICK_TYPE_CUSTOM}:
+        selected = state.picker_selected.pop(prompt.step, [])
+        state.picker_offsets.pop(prompt.step, None)
+        return (
+            ",".join(o.value for o in prompt.options if o.value in selected)
+            if value == _DONE else value
+        )
+    selected = state.picker_selected.setdefault(prompt.step, [])
+    if value in selected:
+        selected.remove(value)
+    elif value in {ALL_STAGES, WHOLE_TASK_STAGE}:
+        selected[:] = [value]
+    else:
+        selected[:] = [v for v in selected if v not in {ALL_STAGES, WHOLE_TASK_STAGE}]
+        selected.append(value)
+    return None

package/runtime/python/okstra_ctl/wizard/state.py

@@ -42,6 +42,8 @@ class WizardState:
     host_runtime: str = "claude-code"
     host_entry_mode: str = "current-session"
     available_functions: list[str] = field(default_factory=list)
+    picker_offsets: dict[str, int] = field(default_factory=dict)
+    picker_selected: dict[str, list[str]] = field(default_factory=dict)
 
     # task identity
     is_new_task: Optional[bool] = None

package/runtime/python/okstra_token_usage/codex.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import json
 import os
+from datetime import datetime, timezone
 from pathlib import Path
 from .jsonl_io import iter_jsonl
 from .paths import CODEX_SESSIONS, codex_session_roots, ts_in_window
@@ -50,6 +51,67 @@ def codex_session_total(jsonl_path: Path) -> dict:
     }
 
 
+def codex_session_window_total(jsonl_path: Path, since: str, until: str) -> dict:
+    """창 안에서 이 세션이 쓴 토큰 — token_count 이벤트의 `last_token_usage` 합.
+
+    in-session 리드(`entryMode: current-session`)의 rollout 은 run 보다 먼저
+    열려 다른 task 도 돌린 세션이라 마지막 `total_token_usage` 스냅샷은 세션
+    전체다. 누적치는 이벤트마다 `last_token_usage` 만큼 늘고 컨텍스트 압축
+    뒤 되돌아가므로(실측 2026-09-08 jobs 리드 세션: 601 이벤트 중 2회 감소),
+    창 끝·시작 누적치의 차가 아니라 창 안 이벤트의 `last_token_usage` 를
+    더한다. `last_token_usage` 가 없는 옛 기록은 직전 누적치와의 차(0 이상)로
+    센다. 창 안 이벤트가 없으면 `available: False`.
+    """
+    keys = (
+        ("totalTokens", "total_tokens"),
+        ("inputTokens", "input_tokens"),
+        ("cachedInputTokens", "cached_input_tokens"),
+        ("outputTokens", "output_tokens"),
+        ("reasoningOutputTokens", "reasoning_output_tokens"),
+    )
+    sums = {name: 0 for name, _raw in keys}
+    previous: dict = {}
+    model_val: str | None = None
+    cwd_val: str | None = None
+    started: str | None = None
+    first: str | None = None
+    last: str | None = None
+    for rec in iter_jsonl(jsonl_path):
+        kind = rec.get("type")
+        payload = rec.get("payload") or {}
+        if kind == "session_meta":
+            cwd_val = payload.get("cwd")
+            started = payload.get("timestamp")
+        elif kind == "turn_context":
+            if model_val is None and payload.get("model"):
+                model_val = payload["model"]
+        elif kind == "event_msg" and payload.get("type") == "token_count":
+            info = payload.get("info") or {}
+            cumulative = info.get("total_token_usage") or {}
+            turn = info.get("last_token_usage")
+            timestamp = str(rec.get("timestamp") or "")
+            if timestamp and ts_in_window(timestamp, since, until):
+                for name, raw in keys:
+                    if isinstance(turn, dict):
+                        sums[name] += turn.get(raw, 0) or 0
+                    else:
+                        sums[name] += max(
+                            0, (cumulative.get(raw, 0) or 0) - (previous.get(raw, 0) or 0)
+                        )
+                if first is None:
+                    first = timestamp
+                last = timestamp
+            previous = cumulative
+    if first is None:
+        return {"totalTokens": 0, "cwd": cwd_val, "model": model_val, "available": False}
+    # 창 안에서 열린 세션은 세션 시작이 곧 창 안 활동의 시작이다. 창보다 먼저
+    # 열린 세션(in-session 리드)은 창 안 첫 이벤트부터 센다.
+    if started and ts_in_window(started, since, until):
+        first = started
+    return {**sums, "cwd": cwd_val, "model": model_val,
+            "startedAt": first, "endedAt": last, "available": True}
+
+
 def find_codex_session(cwd: Path, started_at: str, ended_at: str) -> Path | None:
     """Find the latest codex rollout jsonl in the requested window."""
     sessions = find_codex_sessions(cwd, started_at, ended_at)
@@ -104,14 +166,32 @@ def codex_session_ids(path: Path) -> set[str]:
     return {item for item in ids if item}
 
 
+def _modified_in_window(path: Path, started_at: str, until: str) -> bool:
+    try:
+        mtime = path.stat().st_mtime
+    except OSError:
+        return False
+    modified = datetime.fromtimestamp(mtime, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    return ts_in_window(modified, started_at, None)
+
+
 def find_codex_sessions(
     cwd: Path,
     started_at: str,
     ended_at: str,
     *,
     session_roots: tuple[Path, ...] | None = None,
+    active_before_start: bool = False,
 ) -> list[Path]:
-    """Find codex rollout jsonls whose meta.cwd matches the window."""
+    """Find codex rollout jsonls whose meta.cwd matches the window.
+
+    기본은 창 안에서 *시작한* 세션이다 — exec 래퍼 워커는 dispatch 마다 새
+    rollout 을 열므로 그것으로 충분하다. `active_before_start=True` 는 창보다
+    먼저 시작했지만 창 안에서도 기록이 이어진 세션(파일 mtime 이 창 시작 이후)을
+    더한다. in-session 리드가 그 모양이다: 세션은 run 보다 먼저 태어났으니
+    시작 시각으로 거르면 `no host session started in the run window` 로 빠지고,
+    토큰은 `codex_session_window_total` 이 창으로 잘라 센다.
+    """
     if not started_at or not ended_at:
         return []
     if session_roots is None:
@@ -137,7 +217,12 @@ def find_codex_sessions(
             if session_cwd != target_cwd:
                 continue
             if not ts_in_window(ts, started_at, ended_at):
-                continue
+                if not (
+                    active_before_start
+                    and ts_in_window(ts, None, started_at)
+                    and _modified_in_window(p, started_at, ended_at)
+                ):
+                    continue
             candidates.append((ts, p))
     if not candidates:
         return []

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 (
@@ -32,9 +33,9 @@ from .grok import (
     grok_session_is_non_interactive,
     grok_session_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,10 +638,18 @@ 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` 는 codex 리드 전용 — 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 == "antigravity":
             total = (
@@ -778,19 +787,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 +868,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 +1015,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 +1100,29 @@ def _cli_lead_usage(
         if isinstance(worker, dict)
         for path in ((worker.get("usage") or {}).get("cliSessionPaths") or [])
     }
+    # in-session codex 리드는 run 보다 먼저 열린 세션이다 — 창 안에서 시작한
+    # 세션만 보면 없다고 나오고, 세션 전체를 더하면 다른 task 의 턴이 섞인다.
+    # 창 안에서 활동한 세션을 후보에 넣고 토큰은 창으로 잘라 센다.
+    window = (run_since, run_until) if provider == "codex" else None
+    if provider == "codex":
+        candidates = find_codex_sessions(
+            project_root, run_since, run_until, active_before_start=True,
+        )
+    else:
+        candidates = _cli_sessions_for_windows(
+            provider, project_root, [(run_since, run_until)],
+        )
     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 +1136,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 +1156,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 +1215,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 +1436,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 +1536,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/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.