okstra 0.146.1 → 0.148.0

package/runtime/python/okstra_ctl/run.py

@@ -53,13 +53,31 @@ from .material import (
     related_tasks_inline,
     resolve_related_tasks,
 )
-from .final_report_schema import load_schema
+from .final_report_schema import load_schema_version
 from .final_report_paths import final_report_data_path as _final_report_data_path
 from .lead_events import LeadEvent, append_lead_event
-from .lead_runtime import ALLOWED_LEAD_RUNTIMES
+from .lead_runtime import (
+    ALLOWED_LEAD_RUNTIMES,
+    ARTIFACT_ONLY_LEAD_RUNTIMES,
+    lead_runtime_info,
+)
 from .model_discovery import normalize_execution_for_dispatch
-from .models import ModelAssignment, default_model, resolve_model_metadata
+from .models import (
+    ModelAssignment,
+    default_model,
+    provider_default_model,
+    provider_ids,
+    provider_spec,
+    provider_supports_role,
+    resolve_model_metadata,
+)
 from .schema_excerpt import build_schema_excerpt
+from .runner_resolution import (
+    RunnerResolutionError,
+    native_provider_for_host,
+    resolve_runner,
+)
+from .report_contract import CURRENT_REPORT_SCHEMA_VERSION
 from .path_resolve import relative_to_project_root, resolve_user_file
 from .render import (
     apply_lead_prompt_defaults,
@@ -264,11 +282,14 @@ def _set_data_json_approved_true_if_present(path: Path) -> bool:
     try:
         from .render_final_report import (
             FinalReportRenderError,
-            find_default_template,
+            find_default_template_for_data,
             render,
         )
 
-        rendered = render(data, template_path=find_default_template())
+        rendered = render(
+            data,
+            template_path=find_default_template_for_data(data),
+        )
     except FinalReportRenderError as exc:
         raise PrepareError(
             f"--approve could not re-render approved plan from data.json: {exc}"
@@ -325,10 +346,13 @@ class PrepareInputs:
     evidence_inputs_raw: str = ""
     directive: str = ""
     workers_override: str = ""
+    lead_provider: str = ""
     lead_model: str = ""
     claude_model: str = ""
     codex_model: str = ""
     antigravity_model: str = ""
+    worker_models_raw: str = ""
+    report_writer_provider: str = ""
     report_writer_model: str = ""
     lead_runtime: str = "claude-code"
     lead_runtime_request: str = ""
@@ -739,7 +763,7 @@ def _brief_sha256(path: Path) -> str:
 
 
 def _record_artifact_runtime_render_only_event(inp: PrepareInputs, ctx: dict) -> None:
-    if inp.lead_runtime not in ("codex", "external") or not inp.render_only:
+    if inp.lead_runtime not in ARTIFACT_ONLY_LEAD_RUNTIMES or not inp.render_only:
         return
     append_lead_event(
         Path(ctx["LEAD_EVENTS_PATH"]),
@@ -777,10 +801,16 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
         ("--implementation-option", inp.implementation_option),
         ("--clarification-response", inp.clarification_response_path),
         ("--workers", workers),
+        ("--lead-provider", inp.lead_provider or ctx.get("LEAD_PROVIDER", "")),
         ("--lead-model", inp.lead_model or ctx.get("LEAD_MODEL", "")),
         ("--claude-model", inp.claude_model or ctx.get("CLAUDE_WORKER_MODEL", "")),
         ("--codex-model", inp.codex_model or ctx.get("CODEX_WORKER_MODEL", "")),
         ("--antigravity-model", inp.antigravity_model or ctx.get("ANTIGRAVITY_WORKER_MODEL", "")),
+        ("--worker-model", inp.worker_models_raw),
+        (
+            "--report-writer-provider",
+            inp.report_writer_provider or ctx.get("REPORT_WRITER_PROVIDER", ""),
+        ),
         ("--report-writer-model", inp.report_writer_model or ctx.get("REPORT_WRITER_MODEL", "")),
         ("--lead-runtime", inp.lead_runtime if inp.lead_runtime != "claude-code" else ""),
         ("--executor", inp.executor or ctx.get("EXECUTOR_PROVIDER", "")),
@@ -892,7 +922,7 @@ def _resolve_runtime_assets(workspace_root: Path, inp: PrepareInputs) -> _Resolv
         workspace_root / "templates" / "project-docs" / "task-index.template.md"
     )
     final_report_template = (
-        workspace_root / "templates" / "reports" / "final-report.template.md"
+        workspace_root / "templates" / "reports" / "final-report-v2.template.md"
     )
     lead_contract = workspace_root / "prompts" / "lead" / "okstra-lead-contract.md"
     run_validator = workspace_root / "validators" / "validate-run.py"
@@ -1317,6 +1347,28 @@ def _resolve_pr_template(inp: PrepareInputs) -> tuple[str, str]:
     return str(resolved_tpl.path), resolved_tpl.source
 
 
+@dataclass
+class RoleAssignment:
+    role: str
+    provider: str
+    model_display: str
+    model_execution_value: str
+    runner: str
+    worker_id: str = ""
+
+    def to_payload(self) -> dict[str, str]:
+        payload = {
+            "role": self.role,
+            "provider": self.provider,
+            "model": self.model_display,
+            "modelExecutionValue": self.model_execution_value,
+            "runner": self.runner,
+        }
+        if self.worker_id:
+            payload["workerId"] = self.worker_id
+        return payload
+
+
 @dataclass
 class _ModelBindings:
     """이 run 의 lead/worker 모델 + critic + executor 바인딩.
@@ -1332,6 +1384,7 @@ class _ModelBindings:
     ge: ModelAssignment
     rw: ModelAssignment
     critic_choice: str
+    critic_model_execution: str
     executor_provider: str
     executor_display_name: str
     executor_worker_agent: str
@@ -1339,45 +1392,125 @@ class _ModelBindings:
     codex_worker_execution: str
     antigravity_worker_execution: str
     executor_execution: str
+    lead_assignment: RoleAssignment
+    worker_assignments: tuple[RoleAssignment, ...]
 
 
 def recommended_role_models() -> dict[str, str]:
     """역할 → 추천 모델 display 값 (env override 반영). prepare 의 모델 해소와
     wizard 의 안내 표기가 공유하는 단일 기준점."""
     lead_default = _default("OKSTRA_DEFAULT_LEAD_MODEL", default_model("lead"))
-    return {
+    recommendations = {
         "lead": lead_default,
         "claude": _default("OKSTRA_DEFAULT_CLAUDE_MODEL", default_model("claude")),
         "codex": _default("OKSTRA_DEFAULT_CODEX_MODEL", default_model("codex")),
         "antigravity": _default("OKSTRA_DEFAULT_ANTIGRAVITY_MODEL", default_model("antigravity")),
         "report-writer": _default("OKSTRA_DEFAULT_REPORT_WRITER_MODEL", default_model("report-writer")),
     }
+    for provider in provider_ids("analyser"):
+        recommendations.setdefault(
+            provider, provider_default_model(provider, "analyser")
+        )
+    return recommendations
+
+
+def _parse_worker_model_overrides(raw_value: str) -> dict[str, str]:
+    overrides: dict[str, str] = {}
+    for item in (raw_value or "").split(","):
+        item = item.strip()
+        if not item:
+            continue
+        provider, separator, model = item.partition("=")
+        provider = provider.strip().lower()
+        model = model.strip()
+        if not separator or not provider or not model:
+            raise PrepareError(
+                "--worker-model must use provider=model entries separated by commas"
+            )
+        if provider in overrides:
+            raise PrepareError(f"duplicate --worker-model provider: {provider}")
+        provider_spec(provider)
+        overrides[provider] = model
+    return overrides
+
+
+def _model_for_role(
+    provider: str, raw_value: str, role: str, default_override: str = "",
+) -> ModelAssignment:
+    default_value = default_override or provider_default_model(provider, role)
+    if not default_value:
+        raise PrepareError(f"provider {provider!r} does not define a default for role {role!r}")
+    return resolve_model_metadata(
+        provider=provider,
+        raw_value=raw_value,
+        default_display=default_value,
+        default_execution=default_value,
+    )
+
+
+def _assignment_runner(lead_runtime: str, provider: str, role: str) -> str:
+    try:
+        return resolve_runner(lead_runtime, provider, role).runner
+    except RunnerResolutionError as exc:
+        raise PrepareError(str(exc)) from exc
 
 
 def _resolve_worker_models(inp: PrepareInputs) -> dict:
-    """lead/claude/codex/antigravity/report-writer 모델을 alias → (display, execution) 로 해소."""
+    """Resolve provider models while preserving legacy fixed-provider projections."""
     rec = recommended_role_models()
+    overrides = _parse_worker_model_overrides(inp.worker_models_raw)
+    legacy = {
+        "claude": inp.claude_model,
+        "codex": inp.codex_model,
+        "antigravity": inp.antigravity_model,
+    }
+    provider_models = {}
+    for provider in provider_ids("analyser"):
+        default_override = rec.get(provider, "")
+        provider_models[provider] = _model_for_role(
+            provider, overrides.get(provider, legacy.get(provider, "")),
+            "analyser", default_override,
+        )
+    native_lead_provider = native_provider_for_host(inp.lead_runtime)
+    requested_lead_provider = inp.lead_provider.strip().lower()
+    if (
+        native_lead_provider
+        and requested_lead_provider
+        and requested_lead_provider != native_lead_provider
+    ):
+        host_label = lead_runtime_info(inp.lead_runtime).agent_label
+        raise PrepareError(
+            f"{host_label.removesuffix(' CLI')} host requires provider "
+            f"{native_lead_provider!r} for the in-session lead; provider "
+            f"{requested_lead_provider!r} must be selected as a worker instead"
+        )
+    lead_provider = native_lead_provider or requested_lead_provider or "claude"
+    report_writer_provider = inp.report_writer_provider.strip().lower() or "claude"
+    if not provider_supports_role(lead_provider, "lead"):
+        raise PrepareError(f"provider {lead_provider!r} does not support the lead role")
+    if not provider_supports_role(report_writer_provider, "report-writer"):
+        raise PrepareError(
+            f"provider {report_writer_provider!r} does not support the report-writer role"
+        )
     return {
-        "lead": resolve_model_metadata(
-            provider="claude", raw_value=inp.lead_model,
-            default_display=rec["lead"], default_execution=rec["lead"],
-        ),
-        "cw": resolve_model_metadata(
-            provider="claude", raw_value=inp.claude_model,
-            default_display=rec["claude"], default_execution=rec["claude"],
+        "lead_provider": lead_provider,
+        "report_writer_provider": report_writer_provider,
+        "lead": _model_for_role(
+            lead_provider, inp.lead_model, "lead",
+            rec["lead"] if lead_provider == "claude" else "",
         ),
-        "co": resolve_model_metadata(
-            provider="codex", raw_value=inp.codex_model,
-            default_display=rec["codex"], default_execution=rec["codex"],
-        ),
-        "ge": resolve_model_metadata(
-            provider="antigravity", raw_value=inp.antigravity_model,
-            default_display=rec["antigravity"], default_execution=rec["antigravity"],
-        ),
-        "rw": resolve_model_metadata(
-            provider="claude", raw_value=inp.report_writer_model,
-            default_display=rec["report-writer"], default_execution=rec["report-writer"],
+        "cw": provider_models["claude"],
+        "co": provider_models["codex"],
+        "ge": provider_models["antigravity"],
+        "rw": _model_for_role(
+            report_writer_provider, inp.report_writer_model, "report-writer",
+            rec["report-writer"] if report_writer_provider == "claude" else "",
         ),
+        "providers": provider_models,
+        "worker_model_inputs": {
+            provider: overrides.get(provider, legacy.get(provider, ""))
+            for provider in provider_ids("analyser")
+        },
     }
 
 
@@ -1385,15 +1518,29 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
     """worker 모델 + critic 선택 + executor 바인딩을 한 묶음으로 해소·검증한다."""
     m = _resolve_worker_models(inp)
     critic_choice = (inp.critic or "").strip().lower()
-    if critic_choice not in ("", "off", "claude", "codex", "antigravity"):
+    allowed_critics = ["", "off", *provider_ids("critic")]
+    if critic_choice not in allowed_critics:
         raise PrepareError(
-            f"--critic must be one of: off, claude, codex, antigravity (got: {critic_choice!r})"
+            f"--critic must be one of: {', '.join(allowed_critics[1:])} "
+            f"(got: {critic_choice!r})"
+        )
+    critic_model_execution = ""
+    if critic_choice in provider_ids("critic"):
+        critic_meta = _model_for_role(
+            critic_choice,
+            m["worker_model_inputs"].get(critic_choice, ""),
+            "critic",
+        )
+        critic_model_execution = _normalized_execution(
+            critic_meta, provider=critic_choice, role="critic",
         )
     executor_default = _default("OKSTRA_DEFAULT_EXECUTOR", "claude")
     executor_provider = (inp.executor or executor_default).strip().lower()
-    if executor_provider not in ("claude", "codex", "antigravity"):
+    allowed_executors = provider_ids("executor")
+    if executor_provider not in allowed_executors:
         raise PrepareError(
-            f"--executor must be one of: claude, codex, antigravity (got: {executor_provider!r})"
+            f"--executor must be one of: {', '.join(allowed_executors)} "
+            f"(got: {executor_provider!r})"
         )
     if inp.task_type == "implementation" and executor_provider not in workers:
         raise PrepareError(
@@ -1401,15 +1548,21 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
             f"--workers, but resolved roster is {workers!r}. "
             f"Add it explicitly, e.g. --workers {','.join(sorted(set(workers + [executor_provider])))}."
         )
-    provider_to_meta = {
-        "claude": ("Claude executor", "claude-worker", m["cw"]),
-        "codex": ("Codex executor", "codex-worker", m["co"]),
-        "antigravity": ("Antigravity executor", "antigravity-worker", m["ge"]),
-    }
-    display_name, worker_agent, model_meta = provider_to_meta[executor_provider]
+    model_meta = m["providers"][executor_provider]
+    display_name = f"{provider_spec(executor_provider).display_label} executor"
+    worker_agent = f"{executor_provider}-worker"
+    lead_provider = m["lead_provider"]
+    lead_execution = m["lead"].execution
+    lead_runner = _assignment_runner(inp.lead_runtime, lead_provider, "lead")
+    if lead_runner == "cli-wrapper":
+        lead_execution = _normalized_execution(
+            m["lead"], provider=lead_provider, role="lead",
+        )
+    worker_assignments = _build_worker_assignments(inp, workers, m)
     return _ModelBindings(
         lead=m["lead"], cw=m["cw"], co=m["co"], ge=m["ge"], rw=m["rw"],
         critic_choice=critic_choice,
+        critic_model_execution=critic_model_execution,
         executor_provider=executor_provider,
         executor_display_name=display_name,
         executor_worker_agent=worker_agent,
@@ -1420,9 +1573,42 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
             m["ge"], "antigravity", "worker", workers),
         executor_execution=_normalized_execution(
             model_meta, provider=executor_provider, role="executor"),
+        lead_assignment=RoleAssignment(
+            role="lead",
+            provider=lead_provider,
+            model_display=m["lead"].display,
+            model_execution_value=lead_execution,
+            runner=lead_runner,
+        ),
+        worker_assignments=worker_assignments,
     )
 
 
+def _build_worker_assignments(
+    inp: PrepareInputs, workers: list[str], models: dict,
+) -> tuple[RoleAssignment, ...]:
+    assignments: list[RoleAssignment] = []
+    for worker_id in workers:
+        is_report_writer = worker_id == "report-writer"
+        provider = (
+            models["report_writer_provider"] if is_report_writer else worker_id
+        )
+        role = "report-writer" if is_report_writer else "analyser"
+        meta = models["rw"] if is_report_writer else models["providers"][provider]
+        execution = _worker_execution_value(
+            meta, provider, "worker", [provider],
+        )
+        assignments.append(RoleAssignment(
+            role=role,
+            provider=provider,
+            model_display=meta.display,
+            model_execution_value=execution,
+            runner=_assignment_runner(inp.lead_runtime, provider, role),
+            worker_id=worker_id,
+        ))
+    return tuple(assignments)
+
+
 def _normalized_execution(meta: ModelAssignment, provider: str, role: str) -> str:
     """Route a role's catalog execution value through the CLI-identity normalizer
     so the manifest carries the dispatch-correct spelling. SSOT for the mapping
@@ -1756,7 +1942,7 @@ def _render_lead_prompt_and_snapshot(
     """compute/default 토큰을 ctx 에 주입한 뒤 final-report 템플릿 사본과 lead 실행
     프롬프트를 렌더하고, 프롬프트 스냅샷을 기록한 후 prompt_text 를 돌려준다."""
     # inject populates ctx with compute + default tokens consumed by the lead
-    # prompt render below (claude-execution-prompt.md). The final-report
+    # prompt render below (lead-execution-prompt.md). The final-report
     # template render is effectively a copy (Jinja2 `{{ var }}` syntax does
     # not match `_TOKEN_RE`); routed through render_template_with_ctx for SOT
     # consistency.
@@ -1766,7 +1952,7 @@ def _render_lead_prompt_and_snapshot(
         str(final_report_template), ctx["FINAL_REPORT_TEMPLATE_PATH"], ctx,
     )
     # Per-task-type schema excerpt for the report-writer worker. The full
-    # schema validates the data.json post-hoc (load_schema); the worker only
+    # schema validates the data.json post-hoc; the worker only
     # needs the common structure + this run's task-type block, so we write a
     # scoped excerpt into the instruction-set rather than make the worker read
     # the whole 44 KB / all-task-types schema (whose repo `schemas/...` path is
@@ -1779,7 +1965,9 @@ def _render_lead_prompt_and_snapshot(
     # validation runs against the full schema regardless.
     try:
         _excerpt = build_schema_excerpt(
-            load_schema(), inp.task_type, installed_version()
+            load_schema_version(CURRENT_REPORT_SCHEMA_VERSION),
+            inp.task_type,
+            installed_version(),
         )
         Path(ctx["FINAL_REPORT_SCHEMA_PATH"]).write_text(
             json.dumps(_excerpt, indent=2, ensure_ascii=False) + "\n",
@@ -1787,10 +1975,11 @@ def _render_lead_prompt_and_snapshot(
         )
     except Exception:  # noqa: BLE001 — advisory artifact; never fail prep over it
         pass
-    render_template_with_ctx(
-        str(prompt_template), str(instruction_set / "claude-execution-prompt.md"), ctx,
-    )
-    prompt_text = (instruction_set / "claude-execution-prompt.md").read_text(encoding="utf-8")
+    lead_prompt_path = instruction_set / "lead-execution-prompt.md"
+    legacy_claude_prompt_path = instruction_set / "claude-execution-prompt.md"
+    render_template_with_ctx(str(prompt_template), str(lead_prompt_path), ctx)
+    prompt_text = lead_prompt_path.read_text(encoding="utf-8")
+    legacy_claude_prompt_path.write_text(prompt_text, encoding="utf-8")
     Path(ctx["RUN_PROMPT_SNAPSHOT_FILE"]).parent.mkdir(parents=True, exist_ok=True)
     Path(ctx["RUN_PROMPT_SNAPSHOT_FILE"]).write_text(prompt_text, encoding="utf-8")
     return prompt_text
@@ -1819,10 +2008,22 @@ def _persist_run_inputs(
             "taskBriefAbsolutePath": str(inp.brief_path),
             "directive": inp.directive,
             "workers": selected_reviewers,
+            "leadProvider": models.lead_assignment.provider,
             "leadModel": models.lead.display,
             "claudeModel": models.cw.display,
             "codexModel": models.co.display,
             "antigravityModel": models.ge.display,
+            "workerAssignments": [
+                assignment.to_payload() for assignment in models.worker_assignments
+            ],
+            "reportWriterProvider": next(
+                (
+                    assignment.provider
+                    for assignment in models.worker_assignments
+                    if assignment.worker_id == "report-writer"
+                ),
+                inp.report_writer_provider or "claude",
+            ),
             "reportWriterModel": models.rw.display,
             "executor": models.executor_provider,
             "relatedTasks": inp.related_tasks_raw,
@@ -1919,10 +2120,10 @@ def _finalize_status_and_render_manifests(
     """최종 task/run status 를 확정하고 workflow state 를 재계산한 뒤 team-state,
     task-manifest, task-index, run-manifest, timeline, discovery 산출물을 렌더한다."""
     if inp.render_only:
-        ctx["CURRENT_TASK_STATUS"] = "instruction-set-generated"
+        ctx["CURRENT_TASK_STATUS"] = "ready-for-lead"
         ctx["CURRENT_RUN_STATUS"] = "prepared"
     else:
-        ctx["CURRENT_TASK_STATUS"] = "claude-session-started"
+        ctx["CURRENT_TASK_STATUS"] = "lead-session-started"
         ctx["CURRENT_RUN_STATUS"] = "in-progress"
     ctx["LATEST_REPORT_PATH"] = ctx["FINAL_REPORT_PATH"]
     ctx["LATEST_REPORT_RELATIVE_PATH"] = ctx["FINAL_REPORT_RELATIVE_PATH"]
@@ -2054,7 +2255,7 @@ def _initial_workflow_ctx(
     constants; `_finalize_status_and_render_manifests` recomputes the block once
     the real status is settled.
     """
-    task_status, run_status = "ready-for-claude", "not-run"
+    task_status, run_status = "ready-for-lead", "not-run"
     return {
         "CURRENT_TASK_STATUS": task_status,
         "CURRENT_RUN_STATUS": run_status,
@@ -2085,7 +2286,15 @@ def _model_ctx(models: "_ModelBindings") -> dict[str, str]:
     """Render tokens for every model binding this run resolved."""
     return {
         "LEAD_MODEL": models.lead.display,
-        "LEAD_MODEL_EXECUTION_VALUE": models.lead.execution,
+        "LEAD_MODEL_EXECUTION_VALUE": models.lead_assignment.model_execution_value,
+        "LEAD_PROVIDER": models.lead_assignment.provider,
+        "LEAD_ASSIGNMENT_JSON": json.dumps(
+            models.lead_assignment.to_payload(), ensure_ascii=False,
+        ),
+        "WORKER_ASSIGNMENTS_JSON": json.dumps(
+            [assignment.to_payload() for assignment in models.worker_assignments],
+            ensure_ascii=False,
+        ),
         "CLAUDE_WORKER_MODEL": models.cw.display,
         "CLAUDE_WORKER_MODEL_EXECUTION_VALUE": models.cw.execution,
         "CODEX_WORKER_MODEL": models.co.display,
@@ -2094,12 +2303,20 @@ def _model_ctx(models: "_ModelBindings") -> dict[str, str]:
         "ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE": models.antigravity_worker_execution,
         "REPORT_WRITER_MODEL": models.rw.display,
         "REPORT_WRITER_MODEL_EXECUTION_VALUE": models.rw.execution,
+        "REPORT_WRITER_PROVIDER": next(
+            (
+                assignment.provider for assignment in models.worker_assignments
+                if assignment.worker_id == "report-writer"
+            ),
+            "",
+        ),
         "EXECUTOR_PROVIDER": models.executor_provider,
         "EXECUTOR_DISPLAY_NAME": models.executor_display_name,
         "EXECUTOR_WORKER_AGENT": models.executor_worker_agent,
         "EXECUTOR_MODEL_DISPLAY": models.executor_model_meta.display,
         "EXECUTOR_MODEL_EXECUTION_VALUE": models.executor_execution,
         "CRITIC_CHOICE": models.critic_choice,
+        "CRITIC_MODEL_EXECUTION_VALUE": models.critic_model_execution,
     }
 
 
@@ -2345,6 +2562,7 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     ctx.update({
         "ANALYSIS_PROFILE": inp.task_type,
         "RECOMMENDED_ANALYSERS": selected_reviewers,
+        "HOST_RUNTIME": lead_runtime,
         "LEAD_RUNTIME": lead_runtime,
         "LEAD_RUNTIME_REQUEST": lead_runtime_request,
         "RUNTIME_RESOLUTION_JSON": runtime_resolution_json or "{}",
@@ -2453,10 +2671,13 @@ def main(argv: list[str]) -> int:
         ),
     )
     p.add_argument("--workers", default="", dest="workers_override")
+    p.add_argument("--lead-provider", default="")
     p.add_argument("--lead-model", default="")
     p.add_argument("--claude-model", default="")
     p.add_argument("--codex-model", default="")
     p.add_argument("--antigravity-model", default="")
+    p.add_argument("--worker-model", default="", dest="worker_models_raw")
+    p.add_argument("--report-writer-provider", default="")
     p.add_argument("--report-writer-model", default="")
     p.add_argument(
         "--lead-runtime",
@@ -2465,8 +2686,9 @@ def main(argv: list[str]) -> int:
         dest="lead_runtime",
         help=(
             "Lead runtime adapter. Default: claude-code. `codex` renders "
-            "Codex CLI artifact bundles; `external` renders neutral bootstrap "
-            "bundles for manifest inspection until a dispatch backend is enabled."
+            "Codex CLI artifact bundles; `antigravity` renders Antigravity CLI "
+            "artifact bundles; `external` renders neutral bootstrap bundles for "
+            "manifest inspection until a dispatch backend is enabled."
         ),
     )
     p.add_argument(
@@ -2622,10 +2844,13 @@ def main(argv: list[str]) -> int:
         evidence_inputs_raw=args.evidence_inputs_raw,
         directive=args.directive,
         workers_override=args.workers_override,
+        lead_provider=args.lead_provider,
         lead_model=args.lead_model,
         claude_model=args.claude_model,
         codex_model=args.codex_model,
         antigravity_model=args.antigravity_model,
+        worker_models_raw=args.worker_models_raw,
+        report_writer_provider=args.report_writer_provider,
         report_writer_model=args.report_writer_model,
         lead_runtime=args.lead_runtime,
         lead_runtime_request=args.lead_runtime_request,
@@ -2685,7 +2910,7 @@ def main(argv: list[str]) -> int:
             "claudeSessionId": ctx["CLAUDE_SESSION_ID"],
             "leadModelExecutionValue": ctx["LEAD_MODEL_EXECUTION_VALUE"],
             "projectRoot": ctx["PROJECT_ROOT"],
-            "promptFile": str(Path(ctx["INSTRUCTION_SET_PATH"]) / "claude-execution-prompt.md"),
+            "promptFile": str(Path(ctx["INSTRUCTION_SET_PATH"]) / "lead-execution-prompt.md"),
         }
         print(f"__OKSTRA_LAUNCH__ {json.dumps(machine)}")
     return 0

package/runtime/python/okstra_ctl/runner_resolution.py

@@ -0,0 +1,103 @@
+"""Resolve native versus CLI execution from host and provider capabilities."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .models import (
+    UnknownProviderError,
+    provider_spec,
+    provider_supports_role,
+    provider_wrappers,
+)
+
+NATIVE_SESSION = "native-session"
+CLI_WRAPPER = "cli-wrapper"
+RUNNER_VALUES = frozenset({NATIVE_SESSION, CLI_WRAPPER})
+
+_HOST_NATIVE_PROVIDERS = {
+    "claude-code": frozenset({"claude"}),
+    "codex": frozenset({"codex"}),
+    "antigravity": frozenset({"antigravity"}),
+    "external": frozenset(),
+}
+
+
+def native_provider_for_host(host_runtime: str) -> str:
+    """Return the single provider owned by an in-session host, if any."""
+    providers = _HOST_NATIVE_PROVIDERS.get(host_runtime)
+    if providers is None:
+        allowed = ", ".join(_HOST_NATIVE_PROVIDERS)
+        raise RunnerResolutionError(
+            f"unknown host runtime {host_runtime!r}. Allowed values: {allowed}"
+        )
+    return next(iter(providers), "")
+
+
+class RunnerResolutionError(ValueError):
+    """Raised when an assignment cannot run on the selected host."""
+
+
+@dataclass(frozen=True)
+class RunnerResolution:
+    runner: str
+    wrapper: str
+    reason: str
+
+
+def resolve_runner(
+    host_runtime: str,
+    provider: str,
+    role: str,
+    requested_runner: str = "",
+) -> RunnerResolution:
+    """Resolve an assignment without inferring the host from installed CLIs."""
+    native_providers = _HOST_NATIVE_PROVIDERS.get(host_runtime)
+    if native_providers is None:
+        allowed = ", ".join(_HOST_NATIVE_PROVIDERS)
+        raise RunnerResolutionError(
+            f"unknown host runtime {host_runtime!r}. Allowed values: {allowed}"
+        )
+    try:
+        spec = provider_spec(provider)
+    except UnknownProviderError as exc:
+        raise RunnerResolutionError(str(exc)) from exc
+    if not provider_supports_role(provider, role):
+        raise RunnerResolutionError(
+            f"provider {provider!r} does not support role {role!r}"
+        )
+    requested = (requested_runner or "").strip()
+    if requested and requested not in RUNNER_VALUES:
+        allowed = ", ".join(sorted(RUNNER_VALUES))
+        raise RunnerResolutionError(
+            f"unknown runner {requested!r}. Allowed values: {allowed}"
+        )
+    if requested == NATIVE_SESSION and provider not in native_providers:
+        raise RunnerResolutionError(
+            f"host runtime {host_runtime!r} does not provide native {provider!r} execution"
+        )
+    if requested == NATIVE_SESSION or (not requested and provider in native_providers):
+        return RunnerResolution(
+            runner=NATIVE_SESSION,
+            wrapper="",
+            reason=f"{host_runtime} provides native {provider} execution",
+        )
+    if not spec.wrapper:
+        raise RunnerResolutionError(
+            f"provider {provider!r} has no CLI wrapper for role {role!r}"
+        )
+    return RunnerResolution(
+        runner=CLI_WRAPPER,
+        wrapper=spec.wrapper,
+        reason=f"{host_runtime} uses the registered {provider} CLI wrapper",
+    )
+
+
+def worker_wrapper_registry(report_writer_provider: str = "claude") -> dict[str, str]:
+    """Worker-id wrapper map for dispatch front ends."""
+    wrappers = provider_wrappers("analyser")
+    report_writer = provider_spec(report_writer_provider)
+    if not provider_supports_role(report_writer_provider, "report-writer"):
+        raise RunnerResolutionError(
+            f"provider {report_writer_provider!r} does not support report-writer"
+        )
+    return {**wrappers, "report-writer": report_writer.wrapper}