okstra 0.195.1 → 0.195.2

package/docs/architecture.md

@@ -944,6 +944,7 @@ Tokens used in each run are collected from lead/worker session transcripts and w
   - 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.
+- CLI providers (codex, grok, kimi) report cache reads inside their input count (`cached_input_tokens ⊂ input_tokens`). Their usage blocks carry the same keys as a Claude block — `totalTokens` with the cached part removed, `cacheReadTokens`, and `billableEquivalentTokens` normalized by that model's own rate ratios (`provider_billable_equivalent`) — so the report's cache-read and billable columns are filled for every agent. Their cost stays in `cliEstimatedCostUsd` and on the report's separate CLI row.
 - 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.195.1",
+  "version": "0.195.2",
   "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.195.1",
-  "builtAt": "2026-09-09T11:12:46.377Z",
+  "package": "0.195.2",
+  "builtAt": "2026-09-09T14:40:36.284Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/wizard/prompts.ko.json

@@ -621,14 +621,14 @@
       "options": {
         "model": "{model_ref} — {display}",
         "skip": "추가 안 함{skip_warning}",
-        "__free_input__": "직접 선택 (실행 가능한 전체 후보 {total}개에서 고르기)",
         "skip_warnings": {
           "critic": " — 차단 kind 에서 분석자 표가 1대1 동수면 가를 주체가 없어, 그 항목마다 승인 결정과 Blocks=approval clarification 행이 열립니다 (자동 tie-break 대신 사용자 질문. phase 는 계속 진행됩니다)"
         }
       },
       "labels": {
         "range": "허용 {minimum}..{maximum}개, 권장 {recommended}개",
-        "exact": "정확히 {count}개"
+        "exact": "정확히 {count}개",
+        "single": "{role} 역할의 모델을 하나 고르세요 — 인스턴스는 1개입니다 ({range}). 1번 추천은 프로젝트 modelDefaults(없으면 카탈로그 기본값)이고, 이 역할을 빼려면 '추가 안 함' 입니다"
       },
       "errors": {
         "count_out_of_range": "{range} 골라야 합니다 — 고른 수 {count}개",
@@ -636,31 +636,6 @@
         "unknown_option": "목록에 없는 항목입니다: {values}"
       },
       "echo_variants": {
-        "custom": "role-models: (전체 후보에서 직접 선택)",
-        "skipped": "role-models: (추가 안 함)"
-      }
-    },
-    "role_models_custom": {
-      "label": "{role} 역할의 모델을 전체 후보에서 고르세요 — 고른 만큼 인스턴스를 띄웁니다 ({range})",
-      "echo_template": "role-models: {value}",
-      "options": {
-        "model": "{model_ref} — {display}",
-        "skip": "추가 안 함{skip_warning}",
-        "skip_warnings": {
-          "critic": " — 차단 kind 에서 분석자 표가 1대1 동수면 가를 주체가 없어, 그 항목마다 승인 결정과 Blocks=approval clarification 행이 열립니다 (자동 tie-break 대신 사용자 질문. phase 는 계속 진행됩니다)"
-        }
-      },
-      "labels": {
-        "range": "허용 {minimum}..{maximum}개, 권장 {recommended}개",
-        "exact": "정확히 {count}개"
-      },
-      "errors": {
-        "count_out_of_range": "{range} 골라야 합니다 — 고른 수 {count}개",
-        "min_one_required": "모델을 {range} 고르세요 (이 역할을 빼려면 '추가 안 함')",
-        "unknown_option": "목록에 없는 항목입니다: {values}"
-      },
-      "echo_variants": {
-        "custom": "role-models: (전체 후보에서 직접 선택)",
         "skipped": "role-models: (추가 안 함)"
       }
     }

package/runtime/python/okstra_ctl/report_html/render.py

@@ -191,6 +191,7 @@ def render_v2_html_view(
     response_js = (root / "report.js").read_text(encoding="utf-8")
     base_js = (root / "html/assets/base.js").read_text(encoding="utf-8")
     source_data = final_report_data_path(Path(run_meta.source_report)).as_posix()
+    user_responses_dir = user_responses_dir_for_report(data_path.resolve())
     context = {
         **view.context,
         "runMeta": run_meta,
@@ -215,6 +216,11 @@ def render_v2_html_view(
         # Every task type ends with the same run-cost section, so it is bound
         # here rather than in ten view models that would each rebuild it.
         "runUsage": run_usage(data),
+        # 바닥글이 "여기에 두면" 이라고 가리키는 디렉터리. 상대 경로
+        # `runs/<type>/user-responses/` 는 task 디렉터리 기준이라는 말이 없어
+        # 프로젝트 루트에서 찾으면 없고, implementation 은 stage 아래라 그 경로
+        # 자체가 틀렸다(실측 2026-09-09) — 보고서 파일에서 계산한 절대 경로를 찍는다.
+        "userResponseDir": user_responses_dir.as_posix(),
         "executionRoles": data.get("executionRoles") or [],
         "css": (root / "html/assets/base.css").read_text(encoding="utf-8"),
         "js": response_js + "\n" + base_js,
@@ -223,8 +229,8 @@ def render_v2_html_view(
     document = env.get_template(route.template_name).render(**context)
     document = inject_report_index(document, label=translate("base.contents"))
     output_path.write_text(document, encoding="utf-8")
-    if context["clarificationItems"] or context.get("directionSelection"):
-        # The footer tells the reader to drop the exported file here, so the
-        # directory has to exist before they go looking for it.
-        user_responses_dir_for_report(data_path).mkdir(parents=True, exist_ok=True)
+    # The footer tells the reader to drop the exported file here, so the
+    # directory has to exist before they go looking for it — on every report,
+    # not only those with clarification rows: the footer is rendered on all.
+    user_responses_dir.mkdir(parents=True, exist_ok=True)
     return output_path

package/runtime/python/okstra_ctl/report_projections.py

@@ -49,6 +49,24 @@ def _agent_label(row: Mapping[str, Any]) -> str:
     return _AGENT_LABELS.get(value.lower(), value)
 
 
+def _row_model(row: Mapping[str, Any], usage: Mapping[str, Any]) -> str:
+    """행이 이름한 모델, 없으면 사용량 수집기가 트랜스크립트에서 읽은 모델.
+
+    `/okstra-run` 으로 현재 세션에서 도는 리드는 prepare 시점에 모델을 모른다 —
+    매니페스트 `leadModel` 과 team-state `lead.model` 이 문자 그대로 `unknown`
+    이다. 수집기는 그 세션의 jsonl 에서 `claude-opus-5` 를 읽어 `leadUsage.model`
+    에 적어 두므로, 표는 그 값을 쓴다(실측 2026-09-09: 리드 행 모델 `unknown`).
+    """
+    named = row.get("model") or row.get("modelExecutionValue")
+    if isinstance(named, str) and named.strip() and named.strip() != "unknown":
+        return named.strip()
+    if usage.get("source") != "unavailable":
+        measured = usage.get("model")
+        if isinstance(measured, str) and measured.strip():
+            return measured.strip()
+    return "unknown"
+
+
 def _execution_row(
     row: Mapping[str, Any],
     *,
@@ -65,7 +83,7 @@ def _execution_row(
     result = {
         "agent": _agent_label(row),
         "role": role,
-        "model": _text(row.get("model") or row.get("modelExecutionValue"), "unknown"),
+        "model": _row_model(row, source),
         "status": status,
         "summary": _text(
             row.get("summary") or row.get("reason"),

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

@@ -132,13 +132,23 @@ def next_prompt(state: WizardState) -> Prompt:
 
 
 def _native_picker_screen(state: WizardState, prompt: Prompt) -> Prompt:
+    """호스트 네이티브 선택기 한도에 맞춘 화면.
+
+    단일 선택이 한도를 넘으면 쪽으로 나눈다(`present_picker`). 체크박스(`multi`)는
+    나누지 않는다 — 네이티브 체크박스에 못 실으면 `CapabilityInteractionPort.plan`
+    이 `numbered-multi` 로 내려 전체 목록을 한 번에 보인다. 종전엔 체크박스도
+    한 줄씩 토글하는 쪽으로 내렸는데, claude-code 한도 4 에서 후보 12개는 쪽당
+    2개가 됐고, 쪽 사본이 추천 표시를 단 채 단일 선택이 돼 `Prompt` 의 추천
+    불변식(단일 선택은 추천 정확히 하나)에 걸려 화면이 열리지 않았다(실측
+    2026-09-09, verifier 전체 후보 화면).
+    """
     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":
+    if prompt.multi:
         return prompt
     limit = default_host_registry().resolve(state.host_runtime).interaction().native_option_limit
     return present_picker(state, prompt, limit=limit)
@@ -377,9 +387,8 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     if prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
     if _is_role_selection_step(prompt.step):
-        # 화면은 호스트 한도에 맞춰 쪽으로 잘린 사본일 수 있다(`present_picker`).
-        # 답은 잘리지 않은 원본의 선택지로 검증한다 — 체크박스의 CSV 는 여러
-        # 쪽에 걸쳐 고른 값이다.
+        # 고정 단일 역할의 화면은 호스트 한도에 맞춰 쪽으로 잘린 사본일 수
+        # 있다(`present_picker`). 답은 잘리지 않은 원본의 선택지로 검증한다.
         original = next_role_prompt(state)
         if original is not None and original.step == prompt.step:
             prompt = original

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

@@ -1,28 +1,28 @@
-"""호스트 선택기 한도 안에서 원래 선택지를 보존하는 화면 변환."""
-from dataclasses import replace
+"""호스트 선택기 한도 안에서 단일 선택의 원래 선택지를 보존하는 쪽 나누기.
 
-from okstra_ctl.wizard_stage_intent import WHOLE_TASK_STAGE
+체크박스(`multi`)는 여기 오지 않는다 — 네이티브 체크박스에 못 실으면
+`numbered-multi` 로 전체 목록을 한 번에 보인다(`engine._native_picker_screen`).
+쪽 사본이 추천 표시를 단 채 단일 선택으로 바뀌면 `Prompt` 의 추천 불변식에
+걸리므로, 한 줄씩 토글하던 체크박스 쪽 나누기는 2026-09-09 에 뺐다.
+"""
+from dataclasses import replace
 
-from .ids import ALL_STAGES, PICK_TYPE_CUSTOM
+from .ids import 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 ""),
+        label=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)
+    paged = len(options) > limit
+    size = max(1, limit - 1) 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]
@@ -34,15 +34,12 @@ def present_picker(state: WizardState, prompt: Prompt, *, limit: int) -> Prompt:
             "다음 선택지" 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)
+    return replace(prompt, label=label, options=shown)
 
 
 def accept_picker_answer(state: WizardState, prompt: Prompt, value: str) -> str | None:
@@ -52,24 +49,5 @@ def accept_picker_answer(state: WizardState, prompt: Prompt, value: str) -> str
             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
+    state.picker_offsets.pop(prompt.step, None)
+    return value

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

@@ -7,11 +7,13 @@ verifier: `max > 1`)은 체크박스 한 장이고, 고른 모델 수가 곧 인
 (`min = 0`, 예: critic)은 같은 화면에 "추가 안 함" 줄이 있다(종전 `role-add:`).
 고정 단일 역할(`min = max = 1`, 예: report-writer·implementer)은 단일 선택 한 장이다.
 
-체크박스 화면은 두 장이다. `role-models:<role>` 은 기본 후보(프로젝트
-`modelDefaults` 또는 카탈로그 기본값)만 싣고 권장 수만큼 앞줄을 추천으로 표시한다
-— 호스트 네이티브 선택기의 옵션 한도(claude-code 4, codex 3, grok 15) 안에
-들어가야 체크박스로 렌더되기 때문이다. 마지막 줄 "직접 선택" 이
-`role-models-custom:<role>` 을 열고, 거기에 실행 가능한 전체 후보가 실린다.
+체크박스 화면(`role-models:<role>`)은 실행 가능한 전체 후보를 한 번에 싣는다.
+기본 후보(프로젝트 `modelDefaults`, 없으면 카탈로그 기본값)가 앞이고 권장
+수만큼의 앞줄이 추천이다. 호스트 네이티브 선택기의 옵션 한도(claude-code 4,
+codex 3, grok 15)를 넘으면 `CapabilityInteractionPort.plan` 이 `numbered-multi`
+로 내려 번호 목록이 된다 — 기본 후보만 실은 짧은 화면과 "직접 선택" 이 여는
+두 번째 화면으로 나누던 설계는 2026-09-09 사용자 요청으로 뺐다(후보 12개 중
+3개만 보이고, 두 번째 화면은 쪽 나누기가 추천 불변식을 깨 열리지도 않았다).
 """
 from __future__ import annotations
 
@@ -37,7 +39,6 @@ from okstra_ctl.run import (
     _model_default_scopes,
 )
 
-from .ids import PICK_TYPE_CUSTOM
 from .state import (
     Option,
     Prompt,
@@ -54,7 +55,6 @@ from .prompts import _opt, _p
 ROLE_SKIP_TOKEN = "0"
 
 _MODELS_PREFIX = "role-models:"
-_CUSTOM_PREFIX = "role-models-custom:"
 _SINGLE_PREFIX = "role-model:"
 
 
@@ -62,17 +62,13 @@ def _role_models_prompt_id(role: str) -> str:
     return f"{_MODELS_PREFIX}{role}"
 
 
-def _role_models_custom_prompt_id(role: str) -> str:
-    return f"{_CUSTOM_PREFIX}{role}"
-
-
 def _role_model_prompt_id(role: str, ordinal: int) -> str:
     return f"{_SINGLE_PREFIX}{role}:{ordinal}"
 
 
 def _step_role(step_id: str) -> str:
     """역할 선택 step id 가 가리키는 역할. 역할 선택 step 이 아니면 빈 문자열."""
-    for prefix in (_CUSTOM_PREFIX, _MODELS_PREFIX, _SINGLE_PREFIX):
+    for prefix in (_MODELS_PREFIX, _SINGLE_PREFIX):
         if step_id.startswith(prefix):
             return step_id[len(prefix):].split(":", 1)[0]
     return ""
@@ -131,7 +127,7 @@ def _count_range_text(requirement: RoleRequirement, t: dict) -> str:
 def _role_models_texts(
     state: WizardState, prompt_key: str, requirement: RoleRequirement,
 ) -> dict:
-    """`role_models` / `role_models_custom` 문구. 허용 범위 문장은 `range` 키다."""
+    """`role_models` 문구. 허용 범위 문장은 `range` 키다."""
     probe = _p(state.workspace_root, prompt_key, role=requirement.role, range="")
     range_text = _count_range_text(requirement, probe)
     texts = _p(state.workspace_root, prompt_key, role=requirement.role, range=range_text)
@@ -199,22 +195,6 @@ def _available_role_models(
     return defaults, everything
 
 
-def _shortlist_budget(state: WizardState, requirement: RoleRequirement) -> int:
-    """`role-models:` 화면에 실을 모델 줄 수.
-
-    호스트에 네이티브 선택기가 있으면 그 한도에서 "직접 선택" 한 줄과, 선택
-    역할이면 "추가 안 함" 한 줄을 뺀 수다. 한도를 넘기는 순간
-    `CapabilityInteractionPort.plan` 이 번호 목록으로 내려 체크박스가 아니게
-    된다. 선택기 자체가 없는 호스트는 어차피 번호 목록이므로 자르지 않는다.
-    """
-    functions = set(state.available_functions)
-    if "native_single_select" not in functions and "native_multi_select" not in functions:
-        return 10**6
-    port = default_host_registry().resolve(state.host_runtime).interaction()
-    reserved = 1 + (1 if requirement.min_count == 0 else 0)
-    return max(1, port.native_option_limit - reserved)
-
-
 def _skip_option(requirement: RoleRequirement, t: dict, *, recommended: bool) -> Option:
     # 역할을 빼면 그 역할이 맡던 판정이 사라진다. 그 결과를 아는 역할만 경고를
     # 단다 — 예: critic 이 없으면 분석자 동수를 가를 주체가 없다.
@@ -233,40 +213,34 @@ def _role_models_prompt(
     requirement: RoleRequirement,
     context: AssignmentContext,
     scopes: ModelDefaultScopes,
-    *,
-    full: bool,
 ) -> Prompt:
-    """역할 하나의 모델 화면. `full` 이면 전체 후보, 아니면 기본 후보 + 직접 선택.
+    """역할 하나의 모델 화면 — 실행 가능한 전체 후보, 기본 후보가 앞이다.
 
     추천은 권장 수만큼의 앞줄이다 — 프로젝트 `modelDefaults`(없으면 카탈로그
     기본값) 순서가 그 근거다. 권장이 0인 선택 역할은 "추가 안 함" 이 추천이다.
     """
     role = requirement.role
     pool = context.pool
-    defaults, everything = _available_role_models(
+    _defaults, everything = _available_role_models(
         state, profile, requirement, context, scopes,
     )
     if not everything:
         _validate_role_selection_feasibility(state, profile, context, scopes)
         raise WizardError(f"role {role!r} has no executable model candidates")
-    custom = full
-    if not full:
-        shown = defaults[: _shortlist_budget(state, requirement)]
-        # 기본 후보만으로 최소 수를 못 채우면 줄인 목록은 답이 될 수 없다 —
-        # 같은 화면에 전체 후보를 싣는다.
-        if len(shown) < min(requirement.min_count, len(everything)) or not shown:
-            full = True
-    if full:
-        shown = everything
-    prompt_key = "role_models_custom" if custom else "role_models"
-    t = _role_models_texts(state, prompt_key, requirement)
-    label = t["label"]
+    t = _role_models_texts(state, "role_models", requirement)
+    multi = requirement.max_count > 1
+    # "고른 만큼 인스턴스를 띄웁니다" 는 체크박스 문구다 — 최대 1개인 역할(critic)은
+    # 단일 선택이라 인스턴스가 1개로 고정이고, 문구가 그 사실을 말해야 한다
+    # (실측 2026-09-09, critic 화면이 체크박스 문구를 달고 나왔다).
+    label = t["label"] if multi else t["labels"]["single"].format(
+        role=requirement.role, range=t["range"],
+    )
     optional = requirement.min_count == 0
     skip_first = optional and requirement.recommended_count == 0
     options: list[Option] = []
     if skip_first:
         options.append(_skip_option(requirement, t, recommended=True))
-    for index, model_ref in enumerate(shown):
+    for index, model_ref in enumerate(everything):
         model = pool.resolve(model_ref)
         options.append(_opt(
             model_ref,
@@ -275,18 +249,10 @@ def _role_models_prompt(
         ))
     if optional and not skip_first:
         options.append(_skip_option(requirement, t, recommended=False))
-    if not full:
-        options.append(_opt(
-            PICK_TYPE_CUSTOM,
-            t["options"][PICK_TYPE_CUSTOM].format(total=len(everything)),
-        ))
     return Prompt(
-        step=(
-            _role_models_custom_prompt_id(role) if custom
-            else _role_models_prompt_id(role)
-        ),
+        step=_role_models_prompt_id(role),
         kind="pick",
-        multi=requirement.max_count > 1,
+        multi=multi,
         label=label,
         options=options,
         echo_template=t["echo_template"],
@@ -362,9 +328,6 @@ def _drop_role_selection(state: WizardState, roles: set[str]) -> None:
     for role in roles:
         state.role_models.pop(role, None)
         state.role_counts.pop(role, None)
-    state.role_models_custom = [
-        role for role in state.role_models_custom if role not in roles
-    ]
     state.role_selection_order = [
         step_id for step_id in state.role_selection_order
         if _step_role(step_id) not in roles
@@ -571,14 +534,8 @@ def next_role_prompt(state: WizardState) -> Prompt | None:
             if not selected:
                 return _model_prompt(state, profile, requirement, context, scopes)
             continue
-        if role in state.role_models_custom:
-            return _role_models_prompt(
-                state, profile, requirement, context, scopes, full=True,
-            )
         if role not in state.role_counts:
-            return _role_models_prompt(
-                state, profile, requirement, context, scopes, full=False,
-            )
+            return _role_models_prompt(state, profile, requirement, context, scopes)
         count = state.role_counts[role]
         if count != len(selected) or not (
             (0 if requirement.min_count == 0 else requirement.min_count)
@@ -589,9 +546,7 @@ def next_role_prompt(state: WizardState) -> Prompt | None:
                 state,
                 {later.role for later in requirements[requirements.index(requirement):]},
             )
-            return _role_models_prompt(
-                state, profile, requirement, context, scopes, full=False,
-            )
+            return _role_models_prompt(state, profile, requirement, context, scopes)
     _validate_role_selection_feasibility(state, profile, context, scopes)
     return None
 
@@ -612,20 +567,12 @@ def _submit_role_models(
 ) -> str:
     """체크박스(또는 선택 역할 단일 픽)의 답을 그 역할의 수와 모델로 확정한다."""
     role = requirement.role
-    prompt_key = (
-        "role_models_custom" if prompt.step.startswith(_CUSTOM_PREFIX)
-        else "role_models"
-    )
-    t = _role_models_texts(state, prompt_key, requirement)
+    t = _role_models_texts(state, "role_models", requirement)
     range_text = t["range"]
     # 같은 값이 두 번 오면(번호 목록에서 `1,1`) 한 번으로 센다 — 거절할 일이 아니다.
     picked = list(dict.fromkeys(
         item.strip() for item in (value or "").split(",") if item.strip()
     ))
-    if PICK_TYPE_CUSTOM in picked:
-        if role not in state.role_models_custom:
-            state.role_models_custom.append(role)
-        return t["echo_variants"]["custom"]
     allowed = {option.value for option in prompt.options}
     unknown = [item for item in picked if item not in allowed]
     if unknown:
@@ -638,7 +585,6 @@ def _submit_role_models(
         previous = (state.role_counts.get(role), state.role_models.get(role))
         state.role_counts[role] = 0
         state.role_models.pop(role, None)
-        state.role_models_custom = [r for r in state.role_models_custom if r != role]
         return t["echo_variants"]["skipped"]
     if not requirement.min_count <= len(models) <= requirement.max_count:
         raise WizardError(t["errors"]["count_out_of_range"].format(
@@ -648,7 +594,6 @@ def _submit_role_models(
     previous_models = state.role_models.get(role)
     state.role_counts[role] = len(models)
     state.role_models[role] = list(models)
-    state.role_models_custom = [r for r in state.role_models_custom if r != role]
     try:
         _validate_submitted_role_model(state, profile)
     except WizardError:
@@ -691,7 +636,7 @@ def _submit_role_prompt(state: WizardState, prompt: Prompt, value: str) -> str:
     profile = _load_role_profile_for_state(state)
     role = _step_role(prompt.step)
     requirement = _requirement_for(profile, role)
-    if prompt.step.startswith((_MODELS_PREFIX, _CUSTOM_PREFIX)):
+    if prompt.step.startswith(_MODELS_PREFIX):
         if _fixed_single(requirement):
             raise WizardError(f"role {role!r} takes exactly one model")
         return _submit_role_models(state, profile, requirement, prompt, value)
@@ -731,7 +676,6 @@ def _reset_role_selection_from(state: WizardState, target_step: str) -> None:
 def _clear_role_selection(state: WizardState) -> None:
     state.role_counts.clear()
     state.role_models.clear()
-    state.role_models_custom.clear()
     state.role_selection_order.clear()
     state.answered = [
         step_id

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

@@ -34,8 +34,6 @@ class WizardState:
     role_counts: dict[str, int] = field(default_factory=dict)
     role_models: dict[str, list[str]] = field(default_factory=dict)
     role_selection_order: list[str] = field(default_factory=list)
-    # 체크박스 화면에서 "직접 선택" 을 골라 전체 후보 화면을 기다리는 역할들.
-    role_models_custom: list[str] = field(default_factory=list)
 
     # bootstrap
     workspace_root: str = ""
@@ -45,7 +43,6 @@ class WizardState:
     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
@@ -583,7 +580,7 @@ def _validate_v2_state_fields(data: dict[str, Any]) -> None:
 
 
 def _is_role_selection_step(step_id: str) -> bool:
-    return step_id.startswith(("role-model:", "role-models:", "role-models-custom:"))
+    return step_id.startswith(("role-model:", "role-models:"))
 
 
 def _discard_implicit_leader_selection(state: WizardState) -> None:
@@ -672,7 +669,6 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "executor": "", "critic": "", "critic_pending_text": False,
     "execution_identity_version": 1,
     "role_counts": {}, "role_models": {}, "role_selection_order": [],
-    "role_models_custom": [],
     "reuse_previous": None,
     "use_defaults": None, "workers_override": "",
     "workers_custom_pending": False,

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

@@ -293,7 +293,6 @@ def _submit_reuse_previous(state: WizardState, value: str) -> Optional[str]:
         conversion_payload.setdefault("kimiModel", state.kimi_model)
         state.role_counts.clear()
         state.role_models.clear()
-        state.role_models_custom.clear()
         state.role_selection_order.clear()
         _convert_v1_provider_selections(state, conversion_payload)
     directive = inputs.get("directive")

package/runtime/python/okstra_token_usage/collect.py

@@ -35,7 +35,7 @@ from .grok import (
     grok_session_window_total,
 )
 from .paths import claude_project_dir, find_session_jsonl, utc_now
-from .pricing import antigravity_cost_usd, provider_cost_usd
+from .pricing import antigravity_cost_usd, provider_billable_equivalent, provider_cost_usd
 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 (
@@ -669,21 +669,42 @@ def _cli_session_totals(
     return totals
 
 
+_THREE_RATE_PROVIDERS = frozenset({"codex", "grok", "kimi"})
+
+
 def _cli_usage_block(provider: str, totals: dict, session_paths: list[Path]) -> dict:
+    """CLI 공급자 세션 합계를 보고서가 읽는 usage 블록으로.
+
+    codex·grok·kimi 는 캐시 재읽기를 입력 토큰 안에 넣어 보고한다(codex
+    `cached_input_tokens ⊂ input_tokens`, grok `cachedReadTokens ⊂ inputTokens`).
+    보고서 표는 원시 토큰을 "캐시 재읽기를 뺀 값" 으로 정의하고 캐시 재읽기·과금
+    환산 토큰에 자기 칸을 두므로, claude-jsonl 블록과 같은 키(`cacheReadTokens`,
+    `billableEquivalentTokens`)로 같은 정의의 값을 싣는다 — 종전엔
+    `cachedInputTokens` 키에만 남아 표의 두 칸이 `--` 로 찍혔다(실측 2026-09-09,
+    dev-10627-2 planning 002: grok 890,880 / codex 3,864,448 토큰이 빠짐).
+    비용은 `cliEstimatedCostUsd` 그대로다 — 합계표가 CLI 비용을 별도 행으로 둔다.
+    """
     block = usage_block(totals, source=f"{provider}-cli")
-    block["cliTotalTokens"] = totals.get("totalTokens", 0) or 0
+    cached_input = totals.get("cachedInputTokens", 0) or 0
+    if provider in _THREE_RATE_PROVIDERS and cached_input:
+        block["totalTokens"] = max(0, block["totalTokens"] - cached_input)
+        block["cacheReadTokens"] = cached_input
+    block["cliTotalTokens"] = block["totalTokens"]
     block["cliSessionPaths"] = [str(path) for path in session_paths]
     if totals.get("model"):
         block["model"] = totals["model"]
         block["cliModel"] = totals["model"]
-    if provider in {"codex", "grok", "kimi"}:
-        cost = provider_cost_usd(
-            provider,
+    if provider in _THREE_RATE_PROVIDERS:
+        rates = (
             totals.get("model"),
             totals.get("inputTokens", 0) or 0,
-            totals.get("cachedInputTokens", 0) or 0,
+            cached_input,
             totals.get("outputTokens", 0) or 0,
         )
+        cost = provider_cost_usd(provider, *rates)
+        billable = provider_billable_equivalent(provider, *rates)
+        if billable is not None:
+            block["billableEquivalentTokens"] = billable
     else:
         cost = antigravity_cost_usd(
             totals.get("model"),

package/runtime/python/okstra_token_usage/pricing.py

@@ -239,6 +239,17 @@ def codex_cost_usd(model: str | None, input_t: int, cached_input_t: int, output_
     return round((fresh * pi + cached_input_t * pci + output_t * po) / 1_000_000, 4)
 
 
+_THREE_RATE_TABLES = {
+    "codex": CODEX_PRICING,
+    "grok": GROK_PRICING,
+    "kimi": KIMI_PRICING,
+}
+
+
+def _three_rate_pricing(provider: str, model: str | None) -> tuple | None:
+    return _match_pricing(model, _THREE_RATE_TABLES.get(provider, {}))
+
+
 def provider_cost_usd(
     provider: str,
     model: str | None,
@@ -247,12 +258,7 @@ def provider_cost_usd(
     output_t: int,
 ) -> float | None:
     """Price a three-rate provider without fabricating an unknown model rate."""
-    tables = {
-        "codex": CODEX_PRICING,
-        "grok": GROK_PRICING,
-        "kimi": KIMI_PRICING,
-    }
-    pricing = _match_pricing(model, tables.get(provider, {}))
+    pricing = _three_rate_pricing(provider, model)
     if pricing is None:
         return None
     input_price, cached_price, output_price = pricing
@@ -264,6 +270,33 @@ def provider_cost_usd(
     ) / 1_000_000, 4)
 
 
+def provider_billable_equivalent(
+    provider: str,
+    model: str | None,
+    input_t: int,
+    cached_input_t: int,
+    output_t: int,
+) -> int | None:
+    """세 단가 공급자의 과금 환산 토큰 — `claude_billable_equivalent` 와 같은 정의.
+
+    입력 단가를 1 로 두고 캐시 입력·출력을 그 공급자의 단가 비율로 환산해 더한다
+    (codex gpt-5.6: cached 0.1x, output 6x). 모델 단가가 표에 없으면 None —
+    비용과 마찬가지로 지어내지 않는다.
+    """
+    pricing = _three_rate_pricing(provider, model)
+    if pricing is None:
+        return None
+    input_price, cached_price, output_price = pricing
+    if not input_price:
+        return None
+    fresh_input = max(0, input_t - cached_input_t)
+    return int(round(
+        fresh_input
+        + cached_input_t * (cached_price / input_price)
+        + output_t * (output_price / input_price)
+    ))
+
+
 def antigravity_cost_usd(model: str | None, input_t: int, output_t: int) -> float | None:
     p = _match_pricing(model, GEMINI_PRICING)
     if p is None:

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

@@ -198,7 +198,7 @@ That is the entire interactive flow. The wizard handles:
 - base-ref pick + git rev-parse validation (skipped when reusing an active worktree),
 - `implementation`-only sub-flow: approved-plan path (frontmatter `approved: true` check) + stage pick (`auto` = the earliest incomplete stage whose dependencies are satisfied, or a specific stage number). Implementer slots use role-count / role-model like every other role (`executor` is only a compatibility alias for `implementer`). When an approved plan is selected and a `## PLAN DECISION` sidecar carrying `Status: approved`, exported from the report — matching the plan on source-report·seq — is detected in that run's sibling `user-responses/`, the approve-confirm step expands to 3 options (`yes_apply` recommended: approve + apply the option as exported / `yes` approve only / `no` abort) — `yes_apply` validates the option against the plan's `optionCandidates` before applying it via the existing approval·option path,
 - `release-handoff`-only sub-flow: after the approved plan auto-resolves, a `handoff_stage_pick` multi-select — choose an eligible stage bundle (stage-group) or the whole task (when an accepted whole-task verification report exists); the result goes out as render-args' `stages` key (csv, empty when whole-task),
-- launch selection after identity/worktree steps: one screen per static role, in profile order. A role that can run several instances (`max > 1`) is a checkbox step `role-models:<role>` (`multi: true`) — the number of models checked is the number of instances, there is no separate count question; the label states the profile range and recommended count, the recommended set is flagged, and the last row (`직접 선택`) opens `role-models-custom:<role>` with every executable candidate. An optional role (`min = 0`, e.g. critic) carries a `추가 안 함` row. A fixed single role (`min = max = 1`, e.g. report-writer) is a single pick `role-model:<role>:1`. current-session lead is this session and is listed on the confirmation summary, not as a wizard step. The wizard does not fork on defaults-vs-customize, does not show a provider roster multi-pick, and does not offer a separate implementer-provider pick. Dynamic verifiers are not chosen at launch. `--workers` is compatibility-only, not a launch picker. Repeated `--role-count` / `--role-model` tokens on `renderArgv` are intentional,
+- launch selection after identity/worktree steps: one screen per static role, in profile order. A role that can run several instances (`max > 1`) is a checkbox step `role-models:<role>` (`multi: true`) — the number of models checked is the number of instances, there is no separate count question; the label states the profile range and recommended count, every executable candidate is listed on that one screen (defaults first, the recommended set flagged), and when the list exceeds the host's native checkbox limit the interaction plan is `numbered-multi` — render the whole list, never a shortlist or pages. An optional role (`min = 0`, e.g. critic) carries a `추가 안 함` row. A fixed single role (`min = max = 1`, e.g. report-writer) is a single pick `role-model:<role>:1`. current-session lead is this session and is listed on the confirmation summary, not as a wizard step. The wizard does not fork on defaults-vs-customize, does not show a provider roster multi-pick, and does not offer a separate implementer-provider pick. Dynamic verifiers are not chosen at launch. `--workers` is compatibility-only, not a launch picker. Repeated `--role-count` / `--role-model` tokens on `renderArgv` are intentional,
 - **resume-clarification (in-session equivalent)** — there is no separate mode or flag matching the shell's `okstra.sh --resume-clarification`; two steps of the standard flow carry out its substance. (1) `reuse_previous` (yes/no to reuse the previous run's settings — in `requirements-discovery` / `error-analysis` / `implementation-planning`, only when prior run-inputs exist): YES prefills role-count·role-model·directive·related-tasks at once. (2) `clarification_pick`: if the **task-type's own** previous `final-report` exists it is auto-recommended as the carry-in input (falling back to the newest by mtime across all phases when absent), and the same run's `user-responses/` sidecar (answers the user filled in) is attached alongside. The chosen path is passed to prepare as `--clarification-response` — the user makes the sidecar via the report's `Export user response`, places it in `runs/<task-type>/user-responses/`, and re-runs the same phase,
 - **re-verification scope (`reverify_scope_pick`, `implementation-planning` clarification re-runs only)** — asked right before `confirm` when the re-run is narrowable **or** an answered `C-NNN` traces to no stage. When every answered id traces to a stage: 3 options — `auto` (recommended — leave it to the lead's `okstra incremental-scope` decision) / `full` (re-verify every stage) / Enter directly (a stage-number CSV, validated against the prior report's Stage Map). When an id is unlinked, `auto` is omitted and the user names stages or picks `full`; that unlinked id does not freeze the run at full. The answer goes out as `--reverify-scope` and reaches the lead prompt as the `REVERIFY_SCOPE_MODE` / `REVERIFY_SCOPE_STAGES` tokens; it shapes that CLI's inputs rather than replacing the decision. The confirmation block's `reverify-scope` line names unlinked ids as needing stage numbers, not as a forced full re-run,
 - `release-handoff` PR template override + persist scope,

package/runtime/templates/reports/html/base.template.html

@@ -144,7 +144,7 @@
     <button type="button" data-action="export-user-response">{{ t('base.export-my-answers') }}</button>
     <button type="button" data-action="copy-user-response">{{ t('base.copy') }}</button>
     <button type="button" data-action="dismiss-user-response" hidden>{{ t('base.dismiss') }}</button>
-    <p class="user-response-hint">{{ t('base.export-downloads') }} <code>user-response-{{ runMeta.task_type }}-{{ runMeta.seq }}.md</code>{{ t('base.drop-that-file-into') }} <code>runs/{{ runMeta.task_type }}/user-responses/</code> {{ t('base.and-the-next-run-picks-your-answers-up-on-it') }}</p>
+    <p class="user-response-hint">{{ t('base.export-downloads') }} <code>user-response-{{ runMeta.task_type }}-{{ runMeta.seq }}.md</code>{{ t('base.drop-that-file-into') }} <code>{{ userResponseDir }}</code> {{ t('base.and-the-next-run-picks-your-answers-up-on-it') }}</p>
     <pre id="user-response-output" aria-live="polite"></pre>
   </footer>{% endif %}
   <div class="back-to-top-wrap">