okstra 0.25.1 → 0.27.0

package/runtime/python/okstra_ctl/wizard.py

@@ -84,6 +84,7 @@ S_BRIEF_KEEP = "brief_keep"
 S_BRIEF_PATH = "brief_path"
 S_BASE_REF_PICK = "base_ref_pick"
 S_BASE_REF_TEXT = "base_ref_text"
+S_APPROVED_PLAN_PICK = "approved_plan_pick"
 S_APPROVED_PLAN = "approved_plan"
 S_EXECUTOR = "executor"
 S_DEFAULTS_OR_CUSTOM = "defaults_or_custom"
@@ -94,9 +95,13 @@ S_CLAUDE_MODEL = "claude_model"
 S_CODEX_MODEL = "codex_model"
 S_GEMINI_MODEL = "gemini_model"
 S_REPORT_WRITER_MODEL = "report_writer_model"
+S_DIRECTIVE_PICK = "directive_pick"
 S_DIRECTIVE = "directive"
+S_RELATED_TASKS_PICK = "related_tasks_pick"
 S_RELATED_TASKS = "related_tasks"
+S_CLARIFICATION_PICK = "clarification_pick"
 S_CLARIFICATION = "clarification"
+S_PR_TEMPLATE_PICK = "pr_template_pick"
 S_PR_TEMPLATE = "pr_template"
 S_PR_TEMPLATE_SCOPE = "pr_template_scope"
 S_CONFIRM = "confirm"
@@ -134,6 +139,7 @@ class WizardState:
 
     # impl extras
     approved_plan_path: str = ""
+    approved_plan_pending_text: bool = False
     executor: str = ""
 
     # customize
@@ -145,9 +151,13 @@ class WizardState:
     gemini_model: str = ""
     report_writer_model: str = ""
     directive: str = ""
+    directive_pending_text: bool = False
     related_tasks_raw: str = ""
+    related_tasks_pending_text: bool = False
     clarification_response_path: str = ""
+    clarification_pending_text: bool = False
     pr_template_path: str = ""
+    pr_template_pending_text: bool = False
     pr_template_scope: str = ""  # "once" | "project" | "global"
 
     # confirm / edit
@@ -533,6 +543,81 @@ def _submit_base_ref_text(state: WizardState, value: str) -> Optional[str]:
     return f"base-ref: {ref}"
 
 
+PICK_USE_DEFAULT = "__use_default__"
+PICK_OTHER = "__other__"
+PICK_SKIP = "__skip__"
+PICK_ENTER = "__enter__"
+
+
+def _latest_implementation_planning_report(state: WizardState) -> Optional[Path]:
+    """Find the latest ``final-report-implementation-planning-<seq>.md`` under
+    the current task's runs directory.
+
+    Returns the path relative to ``project_root`` if found, otherwise ``None``.
+    """
+    if not state.task_group or not state.task_id or not state.project_root:
+        return None
+    base = (Path(state.project_root) / ".project-docs" / "okstra" / "tasks"
+            / slugify_task_segment(state.task_group)
+            / slugify_task_segment(state.task_id)
+            / "runs" / "implementation-planning")
+    if not base.is_dir():
+        return None
+    pat = re.compile(r"^final-report-implementation-planning-(\d+)\.md$")
+    best: tuple[int, Path] | None = None
+    for run_dir in base.iterdir():
+        reports = run_dir / "reports"
+        if not reports.is_dir():
+            continue
+        for child in reports.iterdir():
+            m = pat.match(child.name)
+            if not m:
+                continue
+            n = int(m.group(1))
+            if best is None or n > best[0]:
+                best = (n, child)
+    if best is None:
+        return None
+    try:
+        return best[1].relative_to(Path(state.project_root))
+    except ValueError:
+        return best[1]
+
+
+def _build_approved_plan_pick(state: WizardState) -> Prompt:
+    default = _latest_implementation_planning_report(state)
+    options = [
+        _opt(PICK_USE_DEFAULT, f"기본 경로 사용: {default}"),
+        _opt(PICK_OTHER, "다른 경로 입력"),
+    ]
+    return Prompt(
+        step=S_APPROVED_PLAN_PICK, kind="pick",
+        label=f"approved final-report 경로 (기본: {default})",
+        options=options,
+        echo_template="approved-plan(pick): {value}",
+    )
+
+
+def _submit_approved_plan_pick(state: WizardState, value: str) -> Optional[str]:
+    if value == PICK_USE_DEFAULT:
+        default = _latest_implementation_planning_report(state)
+        if default is None:
+            raise WizardError(
+                "기본 approved-plan 경로를 찾을 수 없습니다. '다른 경로 입력'을 선택하세요."
+            )
+        p = _validate_approved_plan(str(default), Path(state.project_root))
+        state.approved_plan_path = str(p)
+        state.approved_plan_pending_text = False
+        return f"approved-plan: {p}"
+    if value == PICK_OTHER:
+        state.approved_plan_pending_text = True
+        state.approved_plan_path = ""
+        return None
+    raise WizardError(
+        f"expected '{PICK_USE_DEFAULT}' or '{PICK_OTHER}', got: {value!r}"
+    )
+
+
 def _build_approved_plan(state: WizardState) -> Prompt:
     return Prompt(
         step=S_APPROVED_PLAN, kind="text",
@@ -544,9 +629,103 @@ def _build_approved_plan(state: WizardState) -> Prompt:
 def _submit_approved_plan(state: WizardState, value: str) -> Optional[str]:
     p = _validate_approved_plan(value, Path(state.project_root))
     state.approved_plan_path = str(p)
+    state.approved_plan_pending_text = False
     return f"approved-plan: {p}"
 
 
+def _build_directive_pick(state: WizardState) -> Prompt:
+    return Prompt(
+        step=S_DIRECTIVE_PICK, kind="pick",
+        label="추가 directive 가 있나요?",
+        options=[
+            _opt(PICK_SKIP, "없음 (건너뛰기)"),
+            _opt(PICK_ENTER, "있음 (입력)"),
+        ],
+        echo_template="directive(pick): {value}",
+    )
+
+
+def _submit_directive_pick(state: WizardState, value: str) -> Optional[str]:
+    if value == PICK_SKIP:
+        state.directive = ""
+        state.directive_pending_text = False
+        return "directive: (none)"
+    if value == PICK_ENTER:
+        state.directive_pending_text = True
+        return None
+    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+
+
+def _build_related_tasks_pick(state: WizardState) -> Prompt:
+    return Prompt(
+        step=S_RELATED_TASKS_PICK, kind="pick",
+        label="관련 task id 목록이 있나요?",
+        options=[
+            _opt(PICK_SKIP, "없음 (건너뛰기)"),
+            _opt(PICK_ENTER, "있음 (입력)"),
+        ],
+        echo_template="related-tasks(pick): {value}",
+    )
+
+
+def _submit_related_tasks_pick(state: WizardState, value: str) -> Optional[str]:
+    if value == PICK_SKIP:
+        state.related_tasks_raw = ""
+        state.related_tasks_pending_text = False
+        return "related-tasks: (none)"
+    if value == PICK_ENTER:
+        state.related_tasks_pending_text = True
+        return None
+    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+
+
+def _build_clarification_pick(state: WizardState) -> Prompt:
+    return Prompt(
+        step=S_CLARIFICATION_PICK, kind="pick",
+        label="clarification-response 파일 경로가 있나요? (follow-up 시에만)",
+        options=[
+            _opt(PICK_SKIP, "없음 (건너뛰기)"),
+            _opt(PICK_ENTER, "있음 (입력)"),
+        ],
+        echo_template="clarification(pick): {value}",
+    )
+
+
+def _submit_clarification_pick(state: WizardState, value: str) -> Optional[str]:
+    if value == PICK_SKIP:
+        state.clarification_response_path = ""
+        state.clarification_pending_text = False
+        return "clarification: (none)"
+    if value == PICK_ENTER:
+        state.clarification_pending_text = True
+        return None
+    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+
+
+def _build_pr_template_pick(state: WizardState) -> Prompt:
+    return Prompt(
+        step=S_PR_TEMPLATE_PICK, kind="pick",
+        label="PR 본문 템플릿 경로를 직접 지정할까요?",
+        options=[
+            _opt(PICK_SKIP, "자동 해석 (project.json → config → 기본)"),
+            _opt(PICK_ENTER, "직접 경로 입력 (1회성 override)"),
+        ],
+        echo_template="pr-template(pick): {value}",
+    )
+
+
+def _submit_pr_template_pick(state: WizardState, value: str) -> Optional[str]:
+    if value == PICK_SKIP:
+        state.pr_template_path = ""
+        state.pr_template_scope = ""
+        state.pr_template_pending_text = False
+        return "pr-template: (auto-resolve)"
+    if value == PICK_ENTER:
+        state.pr_template_pending_text = True
+        return None
+    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+
+
 def _build_executor(state: WizardState) -> Prompt:
     options = [_opt(e, e + (" (default)" if e == "claude" else ""))
                for e in EXECUTORS]
@@ -689,6 +868,7 @@ def _build_directive(state: WizardState) -> Prompt:
 
 def _submit_directive(state: WizardState, value: str) -> Optional[str]:
     state.directive = (value or "").strip()
+    state.directive_pending_text = False
     return f"directive: {state.directive or '(none)'}"
 
 
@@ -702,6 +882,7 @@ def _build_related_tasks(state: WizardState) -> Prompt:
 
 def _submit_related_tasks(state: WizardState, value: str) -> Optional[str]:
     state.related_tasks_raw = (value or "").strip()
+    state.related_tasks_pending_text = False
     return f"related-tasks: {state.related_tasks_raw or '(none)'}"
 
 
@@ -715,6 +896,7 @@ def _build_clarification(state: WizardState) -> Prompt:
 
 def _submit_clarification(state: WizardState, value: str) -> Optional[str]:
     val = (value or "").strip()
+    state.clarification_pending_text = False
     if not val:
         state.clarification_response_path = ""
         return "clarification: (none)"
@@ -734,6 +916,7 @@ def _build_pr_template(state: WizardState) -> Prompt:
 
 def _submit_pr_template(state: WizardState, value: str) -> Optional[str]:
     val = (value or "").strip()
+    state.pr_template_pending_text = False
     if not val:
         state.pr_template_path = ""
         state.pr_template_scope = ""
@@ -860,15 +1043,29 @@ STEPS: list[Step] = [
          applies=lambda s: s.base_ref_pending_text,
          build=_build_base_ref_text, submit=_submit_base_ref_text,
          owns=("base_ref", "base_ref_pending_text")),
+    Step(S_APPROVED_PLAN_PICK,
+         applies=lambda s: (s.task_type == "implementation"
+                            and not s.approved_plan_path
+                            and not s.approved_plan_pending_text
+                            and S_APPROVED_PLAN_PICK not in s.answered
+                            and bool(s.brief_path)
+                            and (s.reuse_worktree is True
+                                 or S_BASE_REF_PICK in s.answered)
+                            and not s.base_ref_pending_text
+                            and _latest_implementation_planning_report(s) is not None),
+         build=_build_approved_plan_pick, submit=_submit_approved_plan_pick,
+         owns=("approved_plan_path", "approved_plan_pending_text")),
     Step(S_APPROVED_PLAN,
          applies=lambda s: (s.task_type == "implementation"
                             and not s.approved_plan_path
                             and bool(s.brief_path)
                             and (s.reuse_worktree is True
                                  or S_BASE_REF_PICK in s.answered)
-                            and not s.base_ref_pending_text),
+                            and not s.base_ref_pending_text
+                            and (s.approved_plan_pending_text
+                                 or _latest_implementation_planning_report(s) is None)),
          build=_build_approved_plan, submit=_submit_approved_plan,
-         owns=("approved_plan_path",)),
+         owns=("approved_plan_path", "approved_plan_pending_text")),
     Step(S_EXECUTOR,
          applies=lambda s: (s.task_type == "implementation"
                             and bool(s.approved_plan_path)
@@ -927,27 +1124,52 @@ STEPS: list[Step] = [
                             and S_REPORT_WRITER_MODEL not in s.answered),
          build=_build_report_writer_model, submit=_submit_report_writer_model,
          owns=("report_writer_model",)),
+    Step(S_DIRECTIVE_PICK,
+         applies=lambda s: (s.use_defaults is False
+                            and S_DIRECTIVE_PICK not in s.answered),
+         build=_build_directive_pick, submit=_submit_directive_pick,
+         owns=("directive", "directive_pending_text")),
     Step(S_DIRECTIVE,
          applies=lambda s: (s.use_defaults is False
+                            and s.directive_pending_text
                             and S_DIRECTIVE not in s.answered),
          build=_build_directive, submit=_submit_directive,
-         owns=("directive",)),
+         owns=("directive", "directive_pending_text")),
+    Step(S_RELATED_TASKS_PICK,
+         applies=lambda s: (s.use_defaults is False
+                            and S_RELATED_TASKS_PICK not in s.answered),
+         build=_build_related_tasks_pick, submit=_submit_related_tasks_pick,
+         owns=("related_tasks_raw", "related_tasks_pending_text")),
     Step(S_RELATED_TASKS,
          applies=lambda s: (s.use_defaults is False
+                            and s.related_tasks_pending_text
                             and S_RELATED_TASKS not in s.answered),
          build=_build_related_tasks, submit=_submit_related_tasks,
-         owns=("related_tasks_raw",)),
+         owns=("related_tasks_raw", "related_tasks_pending_text")),
+    Step(S_CLARIFICATION_PICK,
+         applies=lambda s: (s.use_defaults is False
+                            and S_CLARIFICATION_PICK not in s.answered),
+         build=_build_clarification_pick, submit=_submit_clarification_pick,
+         owns=("clarification_response_path", "clarification_pending_text")),
     Step(S_CLARIFICATION,
          applies=lambda s: (s.use_defaults is False
+                            and s.clarification_pending_text
                             and S_CLARIFICATION not in s.answered),
          build=_build_clarification, submit=_submit_clarification,
-         owns=("clarification_response_path",)),
+         owns=("clarification_response_path", "clarification_pending_text")),
+    Step(S_PR_TEMPLATE_PICK,
+         applies=lambda s: (s.use_defaults is False
+                            and s.task_type == "release-handoff"
+                            and S_PR_TEMPLATE_PICK not in s.answered),
+         build=_build_pr_template_pick, submit=_submit_pr_template_pick,
+         owns=("pr_template_path", "pr_template_scope", "pr_template_pending_text")),
     Step(S_PR_TEMPLATE,
          applies=lambda s: (s.use_defaults is False
                             and s.task_type == "release-handoff"
+                            and s.pr_template_pending_text
                             and S_PR_TEMPLATE not in s.answered),
          build=_build_pr_template, submit=_submit_pr_template,
-         owns=("pr_template_path", "pr_template_scope")),
+         owns=("pr_template_path", "pr_template_scope", "pr_template_pending_text")),
     Step(S_PR_TEMPLATE_SCOPE,
          applies=lambda s: (s.use_defaults is False
                             and s.task_type == "release-handoff"
@@ -1021,11 +1243,15 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "profile_workers": [], "keep_existing_brief": None,
     "brief_path": "", "reuse_worktree": None, "base_ref": "",
     "base_ref_pending_text": False, "approved_plan_path": "",
+    "approved_plan_pending_text": False,
     "executor": "", "use_defaults": None, "workers_override": "",
     "lead_model": "", "claude_model": "", "codex_model": "",
     "gemini_model": "", "report_writer_model": "", "directive": "",
-    "related_tasks_raw": "", "clarification_response_path": "",
-    "pr_template_path": "", "pr_template_scope": "",
+    "directive_pending_text": False,
+    "related_tasks_raw": "", "related_tasks_pending_text": False,
+    "clarification_response_path": "", "clarification_pending_text": False,
+    "pr_template_path": "", "pr_template_pending_text": False,
+    "pr_template_scope": "",
     "confirmed": None, "edit_target": "",
 }
 
@@ -1172,7 +1398,7 @@ def _cli(argv: list[str]) -> int:
 
     Subcommands:
       init  --state-file PATH --workspace-root P --project-root P --project-id ID
-      step  --state-file PATH [--answer VALUE]
+      step  --state-file PATH (--answer VALUE | --no-submit)
       render-args --state-file PATH
       confirmation --state-file PATH
     """
@@ -1190,6 +1416,11 @@ def _cli(argv: list[str]) -> int:
     p_step = sub.add_parser("step")
     p_step.add_argument("--state-file", required=True)
     p_step.add_argument("--answer", default=None)
+    p_step.add_argument(
+        "--no-submit",
+        action="store_true",
+        help="Fetch the current prompt without submitting an answer.",
+    )
 
     p_render = sub.add_parser("render-args")
     p_render.add_argument("--state-file", required=True)
@@ -1214,8 +1445,26 @@ def _cli(argv: list[str]) -> int:
 
     if args.cmd == "step":
         state = load_state_file(state_path)
+        if args.no_submit and args.answer is not None:
+            print(json.dumps(
+                {"ok": False, "error": "--no-submit and --answer are mutually exclusive"},
+                ensure_ascii=False, indent=2,
+            ))
+            return 2
+        if not args.no_submit and args.answer is None:
+            print(json.dumps(
+                {
+                    "ok": False,
+                    "error": (
+                        "step requires --answer VALUE (use --answer '' to submit an "
+                        "empty value, or --no-submit to peek at the current prompt)"
+                    ),
+                },
+                ensure_ascii=False, indent=2,
+            ))
+            return 2
         try:
-            if args.answer is None:
+            if args.no_submit:
                 result = {"echo": "", "next": next_prompt(state).to_json()}
             else:
                 result = submit(state, args.answer)

package/runtime/python/okstra_token_usage/blocks.py

@@ -18,18 +18,21 @@ def usage_block(totals: dict, source: str, note: str | None = None) -> dict:
         "source": source,
         "collectedAt": utc_now(),
     }
-    for key in ("cacheCreationTokens", "cacheReadTokens", "cachedInputTokens",
+    for key in ("cacheCreationTokens", "cacheCreation5mTokens", "cacheCreation1hTokens",
+                "cacheReadTokens", "cachedInputTokens",
                 "reasoningOutputTokens", "cachedTokens", "thoughtsTokens", "toolTokens"):
         if totals.get(key):
             block[key] = totals[key]
 
     # Billable-equivalent + cost.
     if source == "claude-jsonl":
+        cc_1h = totals.get("cacheCreation1hTokens", 0) or 0
         be = claude_billable_equivalent(
             totals.get("inputTokens", 0) or 0,
             totals.get("cacheCreationTokens", 0) or 0,
             totals.get("cacheReadTokens", 0) or 0,
             totals.get("outputTokens", 0) or 0,
+            cache_create_1h_t=cc_1h,
         )
         block["billableEquivalentTokens"] = be
         cost = claude_cost_usd(
@@ -38,6 +41,7 @@ def usage_block(totals: dict, source: str, note: str | None = None) -> dict:
             totals.get("cacheCreationTokens", 0) or 0,
             totals.get("cacheReadTokens", 0) or 0,
             totals.get("outputTokens", 0) or 0,
+            cache_create_1h_t=cc_1h,
         )
         if cost is not None:
             block["estimatedCostUsd"] = cost

package/runtime/python/okstra_token_usage/claude.py

@@ -10,6 +10,7 @@ from .paths import claude_project_dir
 def claude_session_totals(jsonl_path: Path) -> dict:
     """Return totals + agentName + assistant model + time window for a Claude session jsonl."""
     input_t = output_t = cache_create_t = cache_read_t = 0
+    cache_create_5m_t = cache_create_1h_t = 0
     tool_uses = 0
     agent_name: str | None = None
     model: str | None = None
@@ -23,8 +24,20 @@ def claude_session_totals(jsonl_path: Path) -> dict:
         if usage:
             input_t += usage.get("input_tokens", 0) or 0
             output_t += usage.get("output_tokens", 0) or 0
-            cache_create_t += usage.get("cache_creation_input_tokens", 0) or 0
+            cc_total = usage.get("cache_creation_input_tokens", 0) or 0
+            cache_create_t += cc_total
             cache_read_t += usage.get("cache_read_input_tokens", 0) or 0
+            # Split into 5m / 1h ephemeral tiers when the API breakdown is
+            # present. If only the aggregate is given, attribute all of it to
+            # the 5m tier (1.25x — the cheaper assumption, matches prior
+            # behavior).
+            cc_break = usage.get("cache_creation") or {}
+            if isinstance(cc_break, dict) and (cc_break.get("ephemeral_5m_input_tokens") is not None
+                                               or cc_break.get("ephemeral_1h_input_tokens") is not None):
+                cache_create_5m_t += cc_break.get("ephemeral_5m_input_tokens", 0) or 0
+                cache_create_1h_t += cc_break.get("ephemeral_1h_input_tokens", 0) or 0
+            else:
+                cache_create_5m_t += cc_total
         if rec.get("type") == "assistant":
             if model is None and msg.get("model"):
                 model = msg["model"]
@@ -51,6 +64,8 @@ def claude_session_totals(jsonl_path: Path) -> dict:
         "inputTokens": input_t,
         "outputTokens": output_t,
         "cacheCreationTokens": cache_create_t,
+        "cacheCreation5mTokens": cache_create_5m_t,
+        "cacheCreation1hTokens": cache_create_1h_t,
         "cacheReadTokens": cache_read_t,
         "toolUses": tool_uses,
         "durationMs": duration_ms,

package/runtime/python/okstra_token_usage/collect.py

@@ -54,14 +54,16 @@ def _aggregate_totals(items: list[dict]) -> dict:
     """
     aggregate: dict = {
         "totalTokens": 0, "inputTokens": 0, "outputTokens": 0,
-        "cacheCreationTokens": 0, "cacheReadTokens": 0,
+        "cacheCreationTokens": 0, "cacheCreation5mTokens": 0, "cacheCreation1hTokens": 0,
+        "cacheReadTokens": 0,
         "toolUses": 0, "durationMs": 0,
         "agentName": None, "model": None,
         "startedAt": None, "endedAt": None,
     }
     for t in items:
         for k in ("totalTokens", "inputTokens", "outputTokens",
-                  "cacheCreationTokens", "cacheReadTokens", "toolUses"):
+                  "cacheCreationTokens", "cacheCreation5mTokens", "cacheCreation1hTokens",
+                  "cacheReadTokens", "toolUses"):
             aggregate[k] += t.get(k, 0) or 0
         if aggregate["agentName"] is None and t.get("agentName"):
             aggregate["agentName"] = t["agentName"]
@@ -210,6 +212,17 @@ def collect(team_state_path: Path, project_root: Path | None = None) -> dict:
     worker_billable = sum((w.get("usage") or {}).get("billableEquivalentTokens", 0) or 0 for w in workers)
     worker_cost = sum((w.get("usage") or {}).get("estimatedCostUsd", 0) or 0 for w in workers)
     cli_cost = sum((w.get("usage") or {}).get("cliEstimatedCostUsd", 0) or 0 for w in workers)
+
+    # Surface models whose pricing lookup failed so the silent-zero case is visible.
+    unmatched_models: list[str] = []
+    if lead.get("model") and lead.get("estimatedCostUsd") is None and (lead.get("totalTokens") or 0) > 0:
+        unmatched_models.append(lead["model"])
+    for w in workers:
+        u = w.get("usage") or {}
+        if u.get("model") and u.get("estimatedCostUsd") is None and (u.get("totalTokens") or 0) > 0:
+            unmatched_models.append(u["model"])
+        if u.get("cliModel") and u.get("cliEstimatedCostUsd") is None and (u.get("cliTotalTokens") or 0) > 0:
+            unmatched_models.append(u["cliModel"])
     state["usageSummary"] = {
         "leadTotalTokens": lead_total,
         "workerTotalTokens": worker_total,
@@ -226,9 +239,10 @@ def collect(team_state_path: Path, project_root: Path | None = None) -> dict:
         "collectedAt": utc_now(),
         "teamName": team_name,
         "sessionsFound": len(claude_sessions),
+        "unmatchedModels": sorted(set(unmatched_models)),
         "definitions": {
             "totalTokens": "Sum of input + output + cache_creation + cache_read tokens (raw processed volume; matches Anthropic API breakdown). Cache reads are 95%+ in long sessions.",
-            "billableEquivalentTokens": "Tokens normalized to base-input-price units (cache_creation x1.25, cache_read x0.1, output x5). Useful when comparing sessions across models or to gauge cost.",
+            "billableEquivalentTokens": "Tokens normalized to base-input-price units (cache_creation_5m x1.25, cache_creation_1h x2.0, cache_read x0.1, output x5). 5m vs 1h is split from usage.cache_creation when the API breakdown is present; otherwise all cache_creation falls into 5m.",
             "estimatedCostUsd": "USD cost using public list pricing for the model recorded in the session. cliWorkers covers Codex/Gemini CLI calls billed under those providers.",
         },
     }