okstra 0.147.0 → 0.148.0

package/runtime/python/okstra_ctl/wizard.py

@@ -45,8 +45,12 @@ from okstra_ctl.models import (
     PROVIDER_MAPPINGS,
     UnknownModelError,
     picker_options,
+    provider_ids,
+    provider_supports_role,
     resolve_model_metadata,
 )
+from okstra_ctl.lead_runtime import lead_runtime_info
+from okstra_ctl.runner_resolution import native_provider_for_host
 from okstra_ctl.clarification_items import (
     scan_approval_gate,
     user_response_sidecars,
@@ -135,10 +139,12 @@ EXECUTORS = ["claude", "codex", "antigravity"]
 
 # 역할 한 줄 설명 — defaults_or_custom 안내에서 각 역할이 무슨 일을 하는지 보여준다.
 ROLE_BLURBS = {
-    "lead": "Claude lead · 워커 dispatch·교차검증 수렴·최종 합성",
+    "lead": "Okstra lead · 워커 dispatch·교차검증 수렴·최종 합성",
     "claude": "독립 분석 워커 (Claude)",
     "codex": "독립 분석 워커 (Codex)",
     "antigravity": "독립 분석 워커 (Antigravity)",
+    "grok": "독립 분석 워커 (Grok)",
+    "kimi": "독립 분석 워커 (Kimi)",
     "report-writer": "최종 리포트 작성 (분석은 하지 않음)",
 }
 
@@ -165,6 +171,8 @@ HOST_PICK_OPTION_CAP = 4
 CLAUDE_MODEL_OPTIONS = ["default", *picker_options("claude")]
 CODEX_MODEL_OPTIONS = ["default", *picker_options("codex")]
 ANTIGRAVITY_MODEL_OPTIONS = ["default", *picker_options("antigravity")]
+GROK_MODEL_OPTIONS = ["default", *picker_options("grok")]
+KIMI_MODEL_OPTIONS = ["default", *picker_options("kimi")]
 
 # special pick value: start a brand-new task
 TASK_PICK_NEW_TOKEN = "__new__"
@@ -315,6 +323,8 @@ S_EXECUTOR_MODEL = "executor_model"
 S_CLAUDE_MODEL = "claude_model"
 S_CODEX_MODEL = "codex_model"
 S_ANTIGRAVITY_MODEL = "antigravity_model"
+S_GROK_MODEL = "grok_model"
+S_KIMI_MODEL = "kimi_model"
 S_REPORT_WRITER_MODEL = "report_writer_model"
 S_DIRECTIVE_PICK = "directive_pick"
 S_DIRECTIVE = "directive"
@@ -341,7 +351,8 @@ GROUP_MAX_TABS = 4  # AskUserQuestion 의 질문(탭) 수 한도
 # *_TEXT 후속 / workers_override / pr_template_scope 는 의존성 때문에 개별 유지.
 PROMPT_GROUPS: dict[str, tuple[str, ...]] = {
     GROUP_MODELS: (S_LEAD_MODEL, S_EXECUTOR_MODEL, S_CLAUDE_MODEL,
-                   S_CODEX_MODEL, S_ANTIGRAVITY_MODEL, S_REPORT_WRITER_MODEL),
+                   S_CODEX_MODEL, S_ANTIGRAVITY_MODEL, S_GROK_MODEL,
+                   S_KIMI_MODEL, S_REPORT_WRITER_MODEL),
     GROUP_OPTIONS: (S_DIRECTIVE_PICK, S_RELATED_TASKS_PICK,
                     S_CLARIFICATION_PICK, S_PR_TEMPLATE_PICK),
 }
@@ -362,6 +373,7 @@ class WizardState:
     workspace_root: str = ""
     project_root: str = ""
     project_id: str = ""
+    host_runtime: str = "claude-code"
 
     # task identity
     is_new_task: Optional[bool] = None
@@ -432,10 +444,14 @@ class WizardState:
     # customize
     use_defaults: Optional[bool] = None
     workers_override: str = ""
+    lead_provider: str = ""
     lead_model: str = ""
     claude_model: str = ""
     codex_model: str = ""
     antigravity_model: str = ""
+    grok_model: str = ""
+    kimi_model: str = ""
+    report_writer_provider: str = ""
     report_writer_model: str = ""
     directive: str = ""
     directive_pending_text: bool = False
@@ -3141,7 +3157,8 @@ _REUSE_FILLED_STEPS = (
     S_PROJECT_EVIDENCE_PICK, S_PROJECT_EVIDENCE,
     S_ANALYSIS_TARGET_PICK, S_ANALYSIS_TARGET,
     S_DEFAULTS_OR_CUSTOM, S_WORKERS_OVERRIDE, S_LEAD_MODEL, S_EXECUTOR_MODEL,
-    S_CLAUDE_MODEL, S_CODEX_MODEL, S_ANTIGRAVITY_MODEL, S_REPORT_WRITER_MODEL,
+    S_CLAUDE_MODEL, S_CODEX_MODEL, S_ANTIGRAVITY_MODEL, S_GROK_MODEL,
+    S_KIMI_MODEL, S_REPORT_WRITER_MODEL,
     S_DIRECTIVE_PICK, S_DIRECTIVE, S_RELATED_TASKS_PICK, S_RELATED_TASKS,
     S_CLARIFICATION_PICK, S_CLARIFICATION)
 
@@ -3205,6 +3222,26 @@ def _safe_model(provider: str, raw: object) -> str:
         return ""
 
 
+def _safe_provider(raw: object, role: str) -> str:
+    provider = raw.strip().lower() if isinstance(raw, str) else ""
+    if not provider:
+        return ""
+    return provider if provider_supports_role(provider, role) else ""
+
+
+def _assignment_model(inputs: dict, worker_id: str, provider: str) -> str:
+    assignments = inputs.get("workerAssignments")
+    if not isinstance(assignments, list):
+        return ""
+    for assignment in assignments:
+        if not isinstance(assignment, dict):
+            continue
+        if assignment.get("workerId") != worker_id:
+            continue
+        return _safe_model(provider, assignment.get("model"))
+    return ""
+
+
 def _build_reuse_previous(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "reuse_previous")
     return Prompt(
@@ -3229,12 +3266,27 @@ def _submit_reuse_previous(state: WizardState, value: str) -> Optional[str]:
     state.workers_override = (
         ",".join(w for w in workers if isinstance(w, str))
         if isinstance(workers, list) else "")
-    state.lead_model = _safe_model("claude", inputs.get("leadModel"))
+    state.lead_provider = _safe_provider(inputs.get("leadProvider"), "lead")
+    lead_provider = state.lead_provider or "claude"
+    native_provider = native_provider_for_host(state.host_runtime)
+    if native_provider and lead_provider != native_provider:
+        raise WizardError(
+            f"previous run used provider {lead_provider!r}, but "
+            f"{state.host_runtime} requires provider {native_provider!r}; "
+            "choose step-by-step re-entry"
+        )
+    state.lead_model = _safe_model(lead_provider, inputs.get("leadModel"))
     state.claude_model = _safe_model("claude", inputs.get("claudeModel"))
     state.codex_model = _safe_model("codex", inputs.get("codexModel"))
     state.antigravity_model = _safe_model("antigravity", inputs.get("antigravityModel"))
+    state.grok_model = _assignment_model(inputs, "grok", "grok")
+    state.kimi_model = _assignment_model(inputs, "kimi", "kimi")
+    state.report_writer_provider = _safe_provider(
+        inputs.get("reportWriterProvider"), "report-writer",
+    )
+    report_writer_provider = state.report_writer_provider or "claude"
     state.report_writer_model = _safe_model(
-        "claude", inputs.get("reportWriterModel"))
+        report_writer_provider, inputs.get("reportWriterModel"))
     directive = inputs.get("directive")
     state.directive = directive if isinstance(directive, str) else ""
     related = inputs.get("relatedTasks")
@@ -3285,7 +3337,7 @@ def _role_model_lines(state: WizardState) -> str:
         ex = state.executor or "claude"
         lines.append(line(f"executor={ex}", "코드 구현 실행자", rec.get(ex, "auto")))
     else:
-        for w in ("claude", "codex", "antigravity"):
+        for w in provider_ids("analyser"):
             if w in roster:
                 lines.append(line(w, ROLE_BLURBS[w], rec[w]))
     if impl or "report-writer" in roster:
@@ -3371,15 +3423,65 @@ def _model_pick(step: str, label: str, options: list[str], echo: str) -> Prompt:
                   options=opts, echo_template=echo)
 
 
+def _qualified_role_model_options(role: str) -> list[str]:
+    options = list(CLAUDE_MODEL_OPTIONS)
+    for provider in provider_ids(role):
+        if provider == "claude":
+            continue
+        options.extend(
+            f"{provider}:{model}" for model in picker_options(provider)
+        )
+    return options
+
+
+def _submit_qualified_role_model(
+    state: WizardState, value: str, role: str, model_field: str, provider_field: str,
+) -> str:
+    raw = (value or "").strip()
+    if ":" not in raw:
+        setattr(state, provider_field, "")
+        setattr(state, model_field, _validate_model("claude", raw))
+        return getattr(state, model_field) or "default"
+    provider, model = (part.strip().lower() for part in raw.split(":", 1))
+    if not provider_supports_role(provider, role):
+        raise WizardError(f"provider {provider!r} does not support the {role} role")
+    setattr(state, provider_field, provider)
+    setattr(state, model_field, _validate_model(provider, model))
+    return raw
+
+
 def _build_lead_model(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "lead_model")
-    return _model_pick(S_LEAD_MODEL, t["label"],
-                       CLAUDE_MODEL_OPTIONS, t["echo_template"])
+    provider = native_provider_for_host(state.host_runtime)
+    options = (
+        ["default", *picker_options(provider)]
+        if provider else _qualified_role_model_options("lead")
+    )
+    return _model_pick(S_LEAD_MODEL, t["label"], options, t["echo_template"])
 
 
 def _submit_lead_model(state: WizardState, value: str) -> Optional[str]:
-    state.lead_model = _validate_model("claude", value)
-    return f"lead-model: {state.lead_model or 'default'}"
+    native_provider = native_provider_for_host(state.host_runtime)
+    if native_provider:
+        raw = (value or "").strip()
+        if ":" in raw:
+            selected_provider, raw = (
+                part.strip().lower() for part in raw.split(":", 1)
+            )
+            if selected_provider != native_provider:
+                host_label = lead_runtime_info(state.host_runtime).agent_label
+                raise WizardError(
+                    f"{host_label.removesuffix(' CLI')} host requires provider "
+                    f"{native_provider!r} "
+                    "for the in-session lead"
+                )
+        state.lead_provider = native_provider
+        state.lead_model = _validate_model(native_provider, raw)
+        return f"lead-model: {native_provider}:{state.lead_model or 'default'}"
+    selected = _submit_qualified_role_model(
+        state, value, "lead", "lead_model", "lead_provider",
+    )
+    return f"lead-model: {selected}"
 
 
 def _build_executor_model(state: WizardState) -> Prompt:
@@ -3431,17 +3533,44 @@ def _submit_antigravity_model(state: WizardState, value: str) -> Optional[str]:
     return f"antigravity-model: {state.antigravity_model or 'default'}"
 
 
+def _build_grok_model(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "grok_model")
+    return _model_pick(
+        S_GROK_MODEL, t["label"], GROK_MODEL_OPTIONS, t["echo_template"],
+    )
+
+
+def _submit_grok_model(state: WizardState, value: str) -> Optional[str]:
+    state.grok_model = _validate_model("grok", value)
+    return f"grok-model: {state.grok_model or 'default'}"
+
+
+def _build_kimi_model(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "kimi_model")
+    return _model_pick(
+        S_KIMI_MODEL, t["label"], KIMI_MODEL_OPTIONS, t["echo_template"],
+    )
+
+
+def _submit_kimi_model(state: WizardState, value: str) -> Optional[str]:
+    state.kimi_model = _validate_model("kimi", value)
+    return f"kimi-model: {state.kimi_model or 'default'}"
+
+
 def _build_report_writer_model(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "report_writer_model")
     return _model_pick(S_REPORT_WRITER_MODEL,
                        t["label"],
-                       CLAUDE_MODEL_OPTIONS,
+                       _qualified_role_model_options("report-writer"),
                        t["echo_template"])
 
 
 def _submit_report_writer_model(state: WizardState, value: str) -> Optional[str]:
-    state.report_writer_model = _validate_model("claude", value)
-    return f"report-writer-model: {state.report_writer_model or 'default'}"
+    selected = _submit_qualified_role_model(
+        state, value, "report-writer", "report_writer_model",
+        "report_writer_provider",
+    )
+    return f"report-writer-model: {selected}"
 
 
 def _build_directive(state: WizardState) -> Prompt:
@@ -3941,7 +4070,7 @@ STEPS: list[Step] = [
          applies=lambda s: (s.use_defaults is False
                             and S_LEAD_MODEL not in s.answered),
          build=_build_lead_model, submit=_submit_lead_model,
-         owns=("lead_model",)),
+         owns=("lead_provider", "lead_model")),
     Step(S_EXECUTOR_MODEL,
          applies=lambda s: (s.use_defaults is False
                             and s.task_type == "implementation"
@@ -3969,13 +4098,27 @@ STEPS: list[Step] = [
                             and S_ANTIGRAVITY_MODEL not in s.answered),
          build=_build_antigravity_model, submit=_submit_antigravity_model,
          owns=("antigravity_model",)),
+    Step(S_GROK_MODEL,
+         applies=lambda s: (s.use_defaults is False
+                            and s.task_type != "implementation"
+                            and "grok" in _resolved_roster(s)
+                            and S_GROK_MODEL not in s.answered),
+         build=_build_grok_model, submit=_submit_grok_model,
+         owns=("grok_model",)),
+    Step(S_KIMI_MODEL,
+         applies=lambda s: (s.use_defaults is False
+                            and s.task_type != "implementation"
+                            and "kimi" in _resolved_roster(s)
+                            and S_KIMI_MODEL not in s.answered),
+         build=_build_kimi_model, submit=_submit_kimi_model,
+         owns=("kimi_model",)),
     Step(S_REPORT_WRITER_MODEL,
          applies=lambda s: (s.use_defaults is False
                             and (s.task_type == "implementation"
                                  or "report-writer" in _resolved_roster(s))
                             and S_REPORT_WRITER_MODEL not in s.answered),
          build=_build_report_writer_model, submit=_submit_report_writer_model,
-         owns=("report_writer_model",)),
+         owns=("report_writer_provider", "report_writer_model")),
     # directive(이번 run 의 추가 지시)는 기본값/커스터마이즈와 무관하게 항상
     # 묻는다 — 매 run 마다 줄 수 있는 입력이므로 'Use defaults' 분기 뒤에 숨기지
     # 않는다. (use_defaults is not None: defaults_or_custom 답 이후에만 등장)
@@ -4151,8 +4294,9 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "executor": "", "critic": "", "critic_pending_text": False,
     "reuse_previous": None,
     "use_defaults": None, "workers_override": "",
-    "lead_model": "", "claude_model": "", "codex_model": "",
-    "antigravity_model": "", "report_writer_model": "", "directive": "",
+    "lead_provider": "", "lead_model": "", "claude_model": "", "codex_model": "",
+    "antigravity_model": "", "grok_model": "", "kimi_model": "",
+    "report_writer_provider": "", "report_writer_model": "", "directive": "",
     "directive_pending_text": False,
     "related_tasks_raw": "", "related_tasks_pending_text": False,
     "clarification_response_path": "", "clarification_pending_text": False,
@@ -4176,13 +4320,15 @@ def _reset_field(state: WizardState, fname: str) -> None:
 # ---- Public API ---------------------------------------------------------
 
 def init_state(
-    *, workspace_root: str, project_root: str, project_id: str
+    *, workspace_root: str, project_root: str, project_id: str,
+    host_runtime: str = "claude-code",
 ) -> WizardState:
     """Bootstrap a new wizard state."""
     return WizardState(
         workspace_root=workspace_root,
         project_root=project_root,
         project_id=project_id,
+        host_runtime=host_runtime,
     )
 
 
@@ -4402,6 +4548,14 @@ def render_args(state: WizardState) -> dict[str, str]:
         for path in (state.feature_evidence_path, state.project_evidence_path)
         if path
     ]
+    worker_models = ",".join(
+        f"{provider}={model}"
+        for provider, model in (
+            ("grok", state.grok_model),
+            ("kimi", state.kimi_model),
+        )
+        if model
+    )
     return {
         "project-root": state.project_root,
         "project-id": state.project_id,
@@ -4420,10 +4574,13 @@ def render_args(state: WizardState) -> dict[str, str]:
         "base-ref": base_ref,
         "workers": workers,
         "directive": state.directive,
+        "lead-provider": state.lead_provider,
         "lead-model": state.lead_model,
         "claude-model": state.claude_model,
         "codex-model": state.codex_model,
         "antigravity-model": state.antigravity_model,
+        "worker-model": worker_models,
+        "report-writer-provider": state.report_writer_provider,
         "report-writer-model": state.report_writer_model,
         "related-tasks": state.related_tasks_raw,
         "clarification-response": state.clarification_response_path,
@@ -4480,15 +4637,25 @@ def confirmation_block(state: WizardState) -> str:
     else:
         roster = state.workers_override or ",".join(state.profile_workers) or "(profile default)"
         lines.append(f"  workers       : {roster}")
-    lines.append(f"  lead-model    : {state.lead_model or 'default'}")
+    lines.append(
+        f"  lead          : {state.lead_provider or 'claude'} / "
+        f"{state.lead_model or 'default'}"
+    )
     if state.claude_model:
         lines.append(f"  claude-model  : {state.claude_model}")
     if state.codex_model:
         lines.append(f"  codex-model   : {state.codex_model}")
     if state.antigravity_model:
         lines.append(f"  antigravity-model  : {state.antigravity_model}")
-    if state.report_writer_model:
-        lines.append(f"  report-writer : {state.report_writer_model}")
+    if state.grok_model:
+        lines.append(f"  grok-model    : {state.grok_model}")
+    if state.kimi_model:
+        lines.append(f"  kimi-model    : {state.kimi_model}")
+    if state.report_writer_model or state.report_writer_provider:
+        lines.append(
+            f"  report-writer : {state.report_writer_provider or 'claude'} / "
+            f"{state.report_writer_model or 'default'}"
+        )
     lines.append(f"  directive     : {state.directive or '(none)'}")
     if state.related_tasks_raw:
         lines.append(f"  related-tasks : {state.related_tasks_raw}")
@@ -4587,6 +4754,11 @@ def _cli(argv: list[str]) -> int:
     p_init.add_argument("--workspace-root", required=True)
     p_init.add_argument("--project-root", required=True)
     p_init.add_argument("--project-id", required=True)
+    p_init.add_argument(
+        "--host-runtime",
+        default="claude-code",
+        choices=("claude-code", "codex", "antigravity", "external"),
+    )
     p_init.add_argument("--critic", default="")
 
     p_step = sub.add_parser("step")
@@ -4615,6 +4787,7 @@ def _cli(argv: list[str]) -> int:
             workspace_root=args.workspace_root,
             project_root=args.project_root,
             project_id=args.project_id,
+            host_runtime=args.host_runtime,
         )
         if args.critic:
             state.critic = args.critic

package/runtime/python/okstra_ctl/worker_artifacts.py

@@ -0,0 +1,46 @@
+"""Provider-registry-derived worker artifact paths."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+from .models import provider_ids
+
+
+def artifact_worker_ids() -> list[str]:
+    """All analysis worker ids plus the non-analysis report writer slot."""
+    return [*provider_ids("analyser"), "report-writer"]
+
+
+def artifacts_from_context(
+    ctx: Mapping[str, Any], *, relative: bool
+) -> dict[str, dict[str, str]]:
+    """Derive prompt/result/error paths without provider-specific branches."""
+    prompt_root = _context_root(ctx, "RUN_PROMPTS", relative)
+    result_root = _context_root(ctx, "WORKER_RESULTS", relative)
+    task_type = str(ctx.get("TASK_TYPE_SEGMENT", ""))
+    prompt_suffix = f"-{task_type}-{ctx.get('RUN_PROMPTS_SEQ', '')}"
+    result_suffix = f"-{task_type}-{ctx.get('WORKER_RESULTS_SEQ', '')}"
+    return {
+        worker_id: {
+            "promptPath": str(prompt_root / f"{worker_id}-worker-prompt{prompt_suffix}.md"),
+            "resultPath": str(result_root / f"{worker_id}-worker{result_suffix}.md"),
+            "errorsSidecarPath": str(
+                result_root / f"{worker_id}-worker-errors{result_suffix}.json"
+            ),
+        }
+        for worker_id in artifact_worker_ids()
+    }
+
+
+def _context_root(ctx: Mapping[str, Any], name: str, relative: bool) -> Path:
+    if name == "WORKER_RESULTS":
+        key = "WORKER_RESULTS_RELATIVE_PATH" if relative else "WORKER_RESULTS_PATH"
+    else:
+        suffix = "RELATIVE_PATH" if relative else "DIR"
+        key = f"{name}_{suffix}"
+    value = str(ctx.get(key, ""))
+    if value or relative:
+        return Path(value)
+    relative_value = str(ctx.get(f"{name}_RELATIVE_PATH", ""))
+    return Path(str(ctx.get("PROJECT_ROOT", ""))) / relative_value

package/runtime/python/okstra_ctl/workers.py

@@ -8,7 +8,9 @@ from __future__ import annotations
 
 from pathlib import Path
 
-ALLOWED_WORKERS = ["claude", "codex", "antigravity", "report-writer"]
+from .models import provider_ids
+
+ALLOWED_WORKERS = provider_ids("analyser") + ["report-writer"]
 DEFAULT_WORKERS = ["claude", "codex", "report-writer"]
 PROFILE_BULLET_HEADERS = {
     "- Workers:",

package/runtime/python/okstra_ctl/workflow.py

@@ -108,7 +108,7 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - `Out-of-plan edits` block listing every file touched outside the approved plan with rationale (empty block preferred)\n"
             '  - validation evidence: actual stdout/stderr and exit code for every pre / mid / post command from the plan (no paraphrased "tests pass")\n'
             "  - TDD evidence for TDD-applicable steps: failing-test output before implementation commit and passing-test output after, with framing SHAs\n"
-            "  - per-verifier sections for every verifier in the resolved roster (`Claude verifier`, `Codex verifier`, plus `Antigravity verifier` when opted in) with independent verdict (PASS / CONCERNS / FAIL) and cited diff snippets; dissent is preserved by `Claude lead`\n"
+            "  - per-verifier sections for every verifier in the resolved roster, with an independent verdict (PASS / CONCERNS / FAIL) and cited diff snippets; dissent is preserved by the Okstra lead\n"
             "  - rollback verification (advisory, never blocks — record the revert path for a human; `result` is ok / not-applicable / advisory — human-run)\n"
             "  - routing recommendation for `final-verification` (ready / needs new error-analysis or planning loop)"
         ),
@@ -125,7 +125,7 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - entering this phase only when the cited final-verification report's `Verdict Token` is exactly `accepted`\n"
             "  - asking the user (via `AskUserQuestion` / interactive prompt) which delivery action to take: `local checkout`, `push + PR`, or `skip` (end the run)\n"
             "  - asking the user to pick a PR base branch from `staging` | `preprod` | `prod` | `main` | `dev` | a user-supplied branch name\n"
-            "  - drafting PR title and PR body **inline as the Claude lead** (no drafter worker, no `Agent` dispatch); the lead reviews its own draft with the user before any mutating git / gh command runs\n"
+            "  - drafting PR title and PR body **inline as the Okstra lead** (no drafter worker and no delegated dispatch); the lead reviews its own draft with the user before any mutating git / gh command runs\n"
             "  - read-only git inspection: `git status`, `git diff`, `git log`, `git rev-parse`\n"
             "  - pushing the current feature branch to its origin remote via `git push -u origin <current-branch>` (the feature branch only — NEVER the base branch)\n"
             "  - creating a pull request via `gh pr create --base <chosen-base> --head <current-branch>`; if a PR with the same head already exists, surface its URL and skip creation\n"
@@ -190,6 +190,8 @@ def compute_workflow_state(
     else:
         if current_task_status in (
             "instruction-set-generated",
+            "ready-for-lead",
+            # Compatibility with task manifests prepared before provider-neutral statuses.
             "ready-for-claude",
             "claude-session-started",
         ):

package/runtime/python/okstra_token_usage/__init__.py

@@ -21,6 +21,7 @@ from .pricing import (
     claude_cost_usd,
     codex_cost_usd,
     antigravity_cost_usd,
+    provider_cost_usd,
 )
 from .report import (
     SubstituteRefusedError,

package/runtime/python/okstra_token_usage/collect.py

@@ -20,7 +20,9 @@ from .antigravity import (
     find_antigravity_sessions,
 )
 from .paths import claude_project_dir, utc_now
-from .pricing import codex_cost_usd, antigravity_cost_usd
+from .pricing import antigravity_cost_usd, provider_cost_usd
+from okstra_ctl.models import provider_wrappers
+from okstra_ctl.lead_runtime import ARTIFACT_ONLY_LEAD_RUNTIMES
 from okstra_ctl.wrapper_status import read_wrapper_status, status_path_for_prompt
 
 
@@ -446,14 +448,16 @@ def _codex_worker_windows(project_root: Path, state: dict) -> dict[str, list[tup
     return windows
 
 
-def _codex_runtime_provider(worker: dict) -> str:
+def _cli_assignment_provider(worker: dict) -> str:
     worker_id = str(worker.get("workerId") or "").strip()
-    agent = str(worker.get("agent") or "").strip()
-    if worker_id == "report-writer":
-        return "codex"
-    if agent in {"codex", "antigravity"}:
-        return agent
-    return ""
+    explicit_provider = str(worker.get("provider") or "").strip()
+    provider = explicit_provider or str(worker.get("agent") or "").strip()
+    runner = str(worker.get("runner") or "").strip()
+    if runner and runner != "cli-wrapper":
+        return ""
+    if not explicit_provider and worker_id == "report-writer":
+        provider = "codex"
+    return provider if provider in provider_wrappers() else ""
 
 
 def _cli_sessions_for_windows(
@@ -482,8 +486,10 @@ def _cli_session_totals(provider: str, session_paths: list[Path]) -> list[dict]:
     for session_path in session_paths:
         if provider == "codex":
             total = codex_session_total(session_path)
-        else:
+        elif provider == "antigravity":
             total = antigravity_session_total(session_path)
+        else:
+            continue
         if total.get("available"):
             totals.append(total)
     return totals
@@ -496,8 +502,9 @@ def _cli_usage_block(provider: str, totals: dict, session_paths: list[Path]) ->
     if totals.get("model"):
         block["model"] = totals["model"]
         block["cliModel"] = totals["model"]
-    if provider == "codex":
-        cost = codex_cost_usd(
+    if provider in {"codex", "grok", "kimi"}:
+        cost = provider_cost_usd(
+            provider,
             totals.get("model"),
             totals.get("inputTokens", 0) or 0,
             totals.get("cachedInputTokens", 0) or 0,
@@ -627,7 +634,7 @@ def _attach_cli_usage(
 ) -> None:
     """Layer aggregated CLI token/cost onto a Claude-side worker ``block``.
 
-    A codex/antigravity worker re-dispatched within one aggregated wrapper
+    A CLI-wrapper worker re-dispatched within one aggregated wrapper
     window produces several rollout jsonls; pricing only the latest (the old
     ``find_codex_session`` -> ``sessions[-1]`` behavior) dropped the earlier
     attempts' tokens. We sum every in-window session here so the redispatched
@@ -653,18 +660,19 @@ def _attach_cli_usage(
             block[key] = cli[key]
 
 
-def _collect_codex_runtime_usage(state: dict, project_root: Path) -> dict:
+def _collect_cli_runtime_usage(state: dict, project_root: Path) -> dict:
     windows_by_worker = _codex_worker_windows(project_root, state)
     state["leadUsage"] = na_block(
-        "Codex lead token accounting is not available yet; worker CLI usage is collected from provider logs."
+        "Host lead token accounting is unavailable; CLI worker usage is collected only from attributable provider logs."
     )
     for worker in state.get("workers", []):
         if not isinstance(worker, dict):
             continue
-        provider = _codex_runtime_provider(worker)
+        provider = _cli_assignment_provider(worker)
         if not provider:
             worker["usage"] = na_block(
-                f"worker provider is not CLI-backed in Codex runtime: {worker.get('agent') or worker.get('workerId')}"
+                "worker is host-native or has 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()
@@ -745,7 +753,7 @@ def _populate_usage_summary(
         "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_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/Antigravity CLI calls billed under those providers.",
+            "estimatedCostUsd": "USD cost using public list pricing for the model recorded in the session. cliWorkers covers attributable registered-provider CLI calls.",
         },
     }
 
@@ -761,8 +769,8 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
     task_key = state.get("taskKey", "")
     team_name = resolve_team_name(state)
     lead_sid = (state.get("lead") or {}).get("sessionId")
-    if state.get("leadRuntime") == "codex":
-        return _collect_codex_runtime_usage(state, cwd)
+    if state.get("leadRuntime") in ARTIFACT_ONLY_LEAD_RUNTIMES:
+        return _collect_cli_runtime_usage(state, cwd)
 
     # 1) Claude sessions (lead + claude-side workers). Cache totals at scan
     # time so we don't re-read the jsonl when a worker matches multiple
@@ -878,9 +886,10 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
             block["additionalSessionIds"] = [sid for sid, _, _ in matched[1:]]
             block["matchedAgentNames"] = sorted({t.get("agentName") for _, _, t in matched if t.get("agentName")})
 
-        # For codex/antigravity workers, sum every CLI session that fell inside
-        # the aggregated wrapper window (re-dispatches leave one rollout each).
-        if agent in ("codex", "antigravity"):
+        # For CLI-wrapper workers, retain execution evidence and attach any
+        # attributable provider transcript usage without treating absence as zero.
+        provider = _cli_assignment_provider(worker)
+        if provider:
             windows, status_path, used_fallback = _worker_cli_windows(
                 cwd,
                 worker,
@@ -888,7 +897,7 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
             )
             _attach_cli_usage(
                 block,
-                agent,
+                provider,
                 cwd,
                 windows,
                 status_path,