okstra 0.146.1 → 0.148.0

package/runtime/python/okstra_ctl/codex_dispatch.py

@@ -1,10 +1,8 @@
-"""Codex lead CLI-worker dispatcher.
+"""CLI-wrapper dispatcher for a Codex-hosted Okstra lead.
 
-This module is intentionally narrower than the Claude Code team dispatcher. It
-reads an already-prepared Codex run manifest and dispatches only workers that
-have a CLI wrapper path. `report-writer` is supported only through explicit
-Codex opt-in because the prepared manifest still records a Claude-side model by
-default.
+The prepared assignment's ``runner`` field is authoritative. Native Codex
+assignments stay in the host session; this module runs only ``cli-wrapper``
+assignments through their registered provider wrappers.
 """
 from __future__ import annotations
 
@@ -64,12 +62,10 @@ from .report_finalize import (
 )
 from .wrapper_status import status_path_for_prompt
 from .worker_prompt_body import REPORT_WRITER_WORKER_ID
+from .models import provider_wrappers
 
 
-SUPPORTED_CLI_WORKERS = {
-    "codex": "okstra-codex-exec.sh",
-    "antigravity": "okstra-antigravity-exec.sh",
-}
+SUPPORTED_CLI_WORKERS = provider_wrappers("analyser")
 MAX_WORKER_ATTEMPTS = 2
 
 
@@ -120,8 +116,6 @@ def build_dispatch_plan(
     okstra_bin: Path | None = None,
     requested_workers: Sequence[str] = (),
     idle_timeout_seconds: int = 600,
-    enable_codex_report_writer: bool = False,
-    report_writer_codex_model: str = "",
     dispatch_kind: str = "initial",
     jobs_file: Path | None = None,
 ) -> DispatchPlan:
@@ -129,7 +123,6 @@ def build_dispatch_plan(
         project_root,
         run_manifest_path,
         requested_workers,
-        enable_codex_report_writer=enable_codex_report_writer,
         select_roster=jobs_file is None,
     )
     if jobs_file is not None:
@@ -148,7 +141,6 @@ def build_dispatch_plan(
             workspace_root=workspace_root,
             team_state=inputs.team_state,
             selected_workers=inputs.selected_workers,
-            report_writer_codex_model=report_writer_codex_model,
         )
         workers = _build_selected_worker_dispatches(
             project_root=inputs.project_root,
@@ -204,35 +196,34 @@ def _load_dispatch_inputs(
     run_manifest_path: Path,
     requested_workers: Sequence[str],
     *,
-    enable_codex_report_writer: bool,
     select_roster: bool = True,
 ) -> _DispatchInputs:
     project_root = project_root.resolve()
     manifest_path = _resolve_project_path(project_root, str(run_manifest_path))
     manifest = _load_json_object(manifest_path, "run manifest")
     _validate_codex_manifest(manifest, manifest_path)
+    team_state_path = _resolve_required_path(project_root, manifest, "teamStatePath")
+    team_state = _load_json_object(team_state_path, "team-state")
     selected_workers = (
         tuple(
             _select_workers(
                 manifest,
+                team_state,
                 requested_workers,
-                enable_codex_report_writer=enable_codex_report_writer,
             )
         )
         if select_roster
         else ()
     )
-    team_state_path = _resolve_required_path(project_root, manifest, "teamStatePath")
-    team_state = _load_json_object(team_state_path, "team-state")
     if select_roster:
         _mark_skipped_workers(
             team_state_path,
             team_state,
             _skipped_worker_reasons(
                 manifest,
+                team_state,
                 selected_workers,
                 requested_workers,
-                enable_codex_report_writer=enable_codex_report_writer,
             ),
         )
     active_context = _load_optional_json_object(
@@ -257,16 +248,11 @@ def _materialize_selected_worker_prompts(
     workspace_root: Path,
     team_state: Mapping[str, Any],
     selected_workers: Sequence[str],
-    report_writer_codex_model: str,
 ) -> tuple[tuple[InitialPromptWorkerRequest, ...], tuple[Path, ...]]:
     worker_requests = tuple(
         InitialPromptWorkerRequest(
             worker_id=worker_id,
-            model=_requested_worker_model(
-                worker_id,
-                team_state,
-                report_writer_codex_model,
-            ),
+            model=_requested_worker_model(worker_id, team_state),
         )
         for worker_id in selected_workers
     )
@@ -472,8 +458,6 @@ def main(argv: Sequence[str] | None = None) -> int:
             okstra_bin=Path(args.okstra_bin) if args.okstra_bin else None,
             requested_workers=_parse_workers(args.workers),
             idle_timeout_seconds=idle_timeout_seconds,
-            enable_codex_report_writer=args.enable_codex_report_writer,
-            report_writer_codex_model=args.report_writer_codex_model,
             dispatch_kind=args.dispatch_kind,
             jobs_file=Path(args.jobs_file) if args.jobs_file else None,
         )
@@ -500,8 +484,6 @@ def _parser() -> argparse.ArgumentParser:
     parser.add_argument("--workers", default="")
     parser.add_argument("--dry-run", action="store_true")
     parser.add_argument("--idle-timeout-seconds", default="600")
-    parser.add_argument("--enable-codex-report-writer", action="store_true")
-    parser.add_argument("--report-writer-codex-model", default="")
     parser.add_argument("--dispatch-kind", default="initial")
     parser.add_argument("--jobs-file", default="")
     return parser
@@ -520,6 +502,8 @@ def _build_worker_dispatch(
     model_execution_value: str,
     prompt_path: Path,
 ) -> WorkerJob:
+    worker_state = _worker_state(team_state, worker_id)
+    provider = _assigned_provider(worker_state, worker_id)
     if worker_id == REPORT_WRITER_WORKER_ID:
         return _build_report_writer_dispatch(
             project_root=project_root,
@@ -530,17 +514,17 @@ def _build_worker_dispatch(
             idle_timeout_seconds=idle_timeout_seconds,
             model_execution_value=model_execution_value,
             prompt_path=prompt_path,
+            provider=provider,
         )
-    worker_state = _worker_state(team_state, worker_id)
     result_path = _resolve_project_path(
         project_root, _require_string(worker_state, "resultPath")
     )
-    wrapper = _resolve_wrapper(worker_id, workspace_root, okstra_bin)
+    wrapper = _resolve_wrapper(provider, workspace_root, okstra_bin)
     worktree_path = _worktree_path(manifest, active_context)
     role = _pane_role(prompt_path)
     return WorkerJob(
         worker_id=worker_id,
-        provider=worker_id,
+        provider=provider,
         backend=BACKEND_CLI_WRAPPER,
         project_root=project_root,
         model_execution_value=model_execution_value,
@@ -566,6 +550,7 @@ def _build_report_writer_dispatch(
     idle_timeout_seconds: int,
     model_execution_value: str,
     prompt_path: Path,
+    provider: str,
 ) -> WorkerJob:
     worker_state = _worker_state(team_state, REPORT_WRITER_WORKER_ID)
     data_json_path = _final_report_data_path(
@@ -577,12 +562,11 @@ def _build_report_writer_dispatch(
     )
     return WorkerJob(
         worker_id=REPORT_WRITER_WORKER_ID,
-        # codex 경로의 report-writer 는 claude 가 아니라 codex wrapper 로 돈다.
-        provider="codex",
+        provider=provider,
         backend=BACKEND_CLI_WRAPPER,
         project_root=project_root,
         model_execution_value=model_execution_value,
-        wrapper_path=_resolve_wrapper("codex", workspace_root, okstra_bin),
+        wrapper_path=_resolve_wrapper(provider, workspace_root, okstra_bin),
         prompt_path=prompt_path,
         result_path=data_json_path,
         worker_result_path=worker_result_path,
@@ -608,46 +592,26 @@ def _validate_codex_manifest(manifest: Mapping[str, Any], path: Path) -> None:
 def _requested_worker_model(
     worker_id: str,
     team_state: Mapping[str, Any],
-    report_writer_codex_model: str,
 ) -> str:
-    if worker_id != REPORT_WRITER_WORKER_ID:
-        return _require_string(
-            _worker_state(team_state, worker_id),
-            "modelExecutionValue",
-        )
-    model = report_writer_codex_model.strip()
-    if model:
-        return model
-    raise DispatchError(
-        "Codex report-writer dispatch requires --report-writer-codex-model"
-    )
+    state = _worker_state(team_state, worker_id)
+    return _require_string(state, "modelExecutionValue")
 
 
 def _select_workers(
     manifest: Mapping[str, Any],
+    team_state: Mapping[str, Any],
     requested_workers: Sequence[str],
-    *,
-    enable_codex_report_writer: bool,
 ) -> list[str]:
     recommended = _string_list(manifest.get("recommendedWorkers"))
     if not recommended:
         raise DispatchError("run manifest has no recommendedWorkers entries")
-    supported_workers = _supported_codex_dispatch_workers(
-        enable_codex_report_writer=enable_codex_report_writer
-    )
+    dispatchable = _dispatchable_workers(recommended, team_state)
     if not requested_workers:
-        selected = [worker for worker in recommended if worker in supported_workers]
+        selected = [worker for worker in recommended if worker in dispatchable]
         if selected:
             return selected
-        if REPORT_WRITER_WORKER_ID in recommended and not enable_codex_report_writer:
-            raise DispatchError(
-                "report-writer requires --enable-codex-report-writer because it "
-                "runs through the Codex wrapper instead of Claude Agent"
-            )
-        supported = ", ".join(sorted(supported_workers))
         raise DispatchError(
-            "run roster has no Codex-dispatch supported worker(s) "
-            f"(CLI dispatcher supports: {supported})"
+            "run roster has no cli-wrapper assignments for codex-dispatch"
         )
 
     selected = list(requested_workers)
@@ -656,17 +620,18 @@ def _select_workers(
         raise DispatchError(
             "requested worker(s) are not in this run roster: " + ", ".join(unknown)
         )
-    if REPORT_WRITER_WORKER_ID in selected and not enable_codex_report_writer:
-        raise DispatchError(
-            "report-writer requires --enable-codex-report-writer because it "
-            "runs through the Codex wrapper instead of Claude Agent"
-        )
-    unsupported = [
+    native = [
         worker for worker in selected
-        if worker not in supported_workers
+        if _assigned_runner(_worker_state(team_state, worker)) == "native-session"
     ]
+    if native:
+        raise DispatchError(
+            "requested worker(s) use runner=native-session and must be dispatched "
+            "by the current Codex host: " + ", ".join(native)
+        )
+    unsupported = [worker for worker in selected if worker not in dispatchable]
     if unsupported:
-        supported = ", ".join(sorted(supported_workers))
+        supported = ", ".join(sorted(dispatchable))
         raise DispatchError(
             "unsupported Codex lead worker(s): "
             + ", ".join(unsupported)
@@ -675,19 +640,37 @@ def _select_workers(
     return selected
 
 
-def _supported_codex_dispatch_workers(*, enable_codex_report_writer: bool) -> set[str]:
-    supported = set(SUPPORTED_CLI_WORKERS)
-    if enable_codex_report_writer:
-        supported.add(REPORT_WRITER_WORKER_ID)
-    return supported
+def _assigned_provider(worker_state: Mapping[str, Any], worker_id: str) -> str:
+    provider = _string_value(worker_state.get("provider"))
+    if provider:
+        return provider
+    return "codex" if worker_id == REPORT_WRITER_WORKER_ID else worker_id
+
+
+def _assigned_runner(worker_state: Mapping[str, Any]) -> str:
+    return _string_value(worker_state.get("runner")) or BACKEND_CLI_WRAPPER
+
+
+def _dispatchable_workers(
+    recommended: Sequence[str], team_state: Mapping[str, Any],
+) -> set[str]:
+    dispatchable = set()
+    for worker_id in recommended:
+        state = _worker_state(team_state, worker_id)
+        provider = _assigned_provider(state, worker_id)
+        if (
+            _assigned_runner(state) == BACKEND_CLI_WRAPPER
+            and provider in SUPPORTED_CLI_WORKERS
+        ):
+            dispatchable.add(worker_id)
+    return dispatchable
 
 
 def _skipped_worker_reasons(
     manifest: Mapping[str, Any],
+    team_state: Mapping[str, Any],
     selected_workers: Sequence[str],
     requested_workers: Sequence[str],
-    *,
-    enable_codex_report_writer: bool,
 ) -> dict[str, str]:
     recommended = _string_list(manifest.get("recommendedWorkers"))
     selected = set(selected_workers)
@@ -696,24 +679,22 @@ def _skipped_worker_reasons(
             worker_id: "skipped by Codex dispatch: worker was not requested in this invocation"
             for worker_id in recommended
             if worker_id not in selected
+            and _assigned_runner(_worker_state(team_state, worker_id))
+            == BACKEND_CLI_WRAPPER
         }
 
-    supported = _supported_codex_dispatch_workers(
-        enable_codex_report_writer=enable_codex_report_writer
-    )
+    supported = _dispatchable_workers(recommended, team_state)
     reasons = {}
     for worker_id in recommended:
         if worker_id in selected:
             continue
-        if worker_id == REPORT_WRITER_WORKER_ID and not enable_codex_report_writer:
-            reasons[worker_id] = (
-                "skipped by Codex dispatch default: report-writer requires "
-                "--enable-codex-report-writer and --report-writer-codex-model"
-            )
-        elif worker_id not in supported:
+        state = _worker_state(team_state, worker_id)
+        if _assigned_runner(state) == "native-session":
+            continue
+        if worker_id not in supported:
             reasons[worker_id] = (
-                "skipped by Codex dispatch default: worker is not supported by "
-                "the Codex CLI dispatcher"
+                "skipped by Codex dispatch default: assigned provider has no "
+                "registered CLI wrapper"
             )
         else:
             reasons[worker_id] = "skipped by Codex dispatch default"

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -135,8 +135,6 @@ def build_dispatch_plan(
     okstra_bin: Path | None = None,
     requested_workers: Sequence[str] = (),
     idle_timeout_seconds: int = 600,
-    enable_report_writer: bool = False,
-    report_writer_model: str = "",
     required_lead_runtime: str | None = None,
     default_backend: str = BACKEND_CLI_WRAPPER,
     supported_worker_wrappers: Mapping[str, str],
@@ -171,8 +169,6 @@ def build_dispatch_plan(
             team_state,
             active_context,
             requested_workers,
-            enable_report_writer,
-            report_writer_model,
             options,
         )
     return DispatchPlan(
@@ -240,11 +236,9 @@ def _jobs_from_roster(
     team_state: Mapping[str, Any],
     active_context: Mapping[str, Any],
     requested_workers: Sequence[str],
-    enable_report_writer: bool,
-    report_writer_model: str,
     options: _BuildOptions,
 ) -> list[WorkerJob]:
-    selected = _select_workers(manifest, requested_workers, enable_report_writer, options)
+    selected = _select_workers(manifest, requested_workers, options)
     _mark_roster_skips(project_root, manifest, team_state, selected, requested_workers, options)
     worker_facts, prompt_paths = _materialize_roster_prompts(
         project_root,
@@ -253,7 +247,6 @@ def _jobs_from_roster(
         manifest,
         team_state,
         selected,
-        report_writer_model,
         options,
     )
     return [
@@ -273,15 +266,12 @@ def _jobs_from_roster(
 def _select_workers(
     manifest: Mapping[str, Any],
     requested_workers: Sequence[str],
-    enable_report_writer: bool,
     options: _BuildOptions,
 ) -> list[str]:
     recommended = _string_list(manifest.get("recommendedWorkers"))
     if not recommended:
         raise DispatchError("run manifest has no recommendedWorkers entries")
     supported = set(options.supported_worker_wrappers)
-    if not enable_report_writer and not requested_workers:
-        supported.discard(REPORT_WRITER_WORKER_ID)
     selected = list(requested_workers) if requested_workers else [w for w in recommended if w in supported]
     unknown = [worker for worker in selected if worker not in recommended]
     if unknown:
@@ -336,11 +326,10 @@ def _materialize_roster_prompts(
     manifest: Mapping[str, Any],
     team_state: Mapping[str, Any],
     selected: Sequence[str],
-    report_writer_model: str,
     options: _BuildOptions,
 ) -> tuple[tuple[_RosterWorkerFacts, ...], tuple[Path, ...]]:
     worker_facts = tuple(
-        _roster_worker_facts(team_state, worker_id, report_writer_model)
+        _roster_worker_facts(team_state, worker_id)
         for worker_id in selected
     )
     try:
@@ -364,13 +353,12 @@ def _materialize_roster_prompts(
 def _roster_worker_facts(
     team_state: Mapping[str, Any],
     worker_id: str,
-    report_writer_model: str,
 ) -> _RosterWorkerFacts:
     state = _worker_state(team_state, worker_id)
     return _RosterWorkerFacts(
         worker_id=worker_id,
-        model=_model_for_worker(worker_id, state, report_writer_model),
-        provider=_provider_for_worker(worker_id),
+        model=_require_string(state, "modelExecutionValue"),
+        provider=_string_value(state.get("provider")) or _provider_for_worker(worker_id),
         result_path=_require_string(state, "resultPath"),
         role=_string_value(state.get("role")) or "worker",
     )
@@ -771,12 +759,6 @@ def _provider_for_worker(worker_id: str) -> str:
     return worker_id
 
 
-def _model_for_worker(worker_id: str, state: Mapping[str, Any], report_writer_model: str) -> str:
-    if worker_id == REPORT_WRITER_WORKER_ID and report_writer_model.strip():
-        return report_writer_model.strip()
-    return _require_string(state, "modelExecutionValue")
-
-
 def _result_path_for_worker(worker_id: str, result_path: Path, manifest: Mapping[str, Any], project_root: Path) -> Path:
     if worker_id != REPORT_WRITER_WORKER_ID:
         return result_path

package/runtime/python/okstra_ctl/final_report_schema.py

@@ -259,20 +259,45 @@ def validate(data: Any, schema: dict) -> list[str]:
     return v.errors
 
 
+SCHEMA_FILENAMES = {
+    "1.0": "final-report-v1.0.schema.json",
+    "2.0": "final-report-v2.0.schema.json",
+}
+
+
+def _locate_and_load_schema(filename: str, start: Path | None = None) -> dict:
+    here = (start or Path(__file__)).resolve()
+    if here.is_file():
+        here = here.parent
+    for parent in [here, *here.parents]:
+        candidate = parent / "schemas" / filename
+        if candidate.is_file():
+            return json.loads(candidate.read_text(encoding="utf-8"))
+    raise SchemaError(f"could not locate schemas/{filename}")
+
+
+def load_schema_version(version: str, start: Path | None = None) -> dict:
+    """Load the final-report schema identified by its data version."""
+    try:
+        filename = SCHEMA_FILENAMES[version]
+    except KeyError as exc:
+        raise SchemaError(f"unsupported final-report schemaVersion: {version}") from exc
+    return _locate_and_load_schema(filename, start=start)
+
+
+def load_schema_for_data(data: dict, start: Path | None = None) -> dict:
+    """Select a schema from the explicit ``schemaVersion`` in *data*."""
+    version = data.get("schemaVersion")
+    if not isinstance(version, str) or not version:
+        raise SchemaError("final-report data has no schemaVersion")
+    return load_schema_version(version, start=start)
+
+
 def load_schema(schema_path: Path | None = None) -> dict:
     """Load the final-report schema. If ``schema_path`` is None, locate
     ``schemas/final-report-v1.0.schema.json`` relative to this file's
     repo root.
     """
-    if schema_path is None:
-        here = Path(__file__).resolve()
-        for parent in [here, *here.parents]:
-            candidate = parent / "schemas" / "final-report-v1.0.schema.json"
-            if candidate.is_file():
-                schema_path = candidate
-                break
-        if schema_path is None:
-            raise SchemaError(
-                "could not locate schemas/final-report-v1.0.schema.json"
-            )
-    return json.loads(Path(schema_path).read_text(encoding="utf-8"))
+    if schema_path is not None:
+        return json.loads(Path(schema_path).read_text(encoding="utf-8"))
+    return load_schema_version("1.0")

package/runtime/python/okstra_ctl/lead_events.py

@@ -1,4 +1,4 @@
-"""Structured JSONL events emitted by non-Claude lead runtimes."""
+"""Structured JSONL events emitted by artifact-accounted lead runtimes."""
 from __future__ import annotations
 
 import json

package/runtime/python/okstra_ctl/lead_runtime.py

@@ -24,8 +24,8 @@ class LeadRuntimeInfo:
         }
 
 
-ALLOWED_LEAD_RUNTIMES = ("claude-code", "codex", "external")
-ARTIFACT_ONLY_LEAD_RUNTIMES = frozenset({"codex", "external"})
+ALLOWED_LEAD_RUNTIMES = ("claude-code", "codex", "antigravity", "external")
+ARTIFACT_ONLY_LEAD_RUNTIMES = frozenset({"codex", "antigravity", "external"})
 
 _LEAD_RUNTIMES = {
     "claude-code": LeadRuntimeInfo(
@@ -50,6 +50,17 @@ _LEAD_RUNTIMES = {
         has_claude_session=False,
         adapter_contract_relative_path="lead/adapters/codex.md",
     ),
+    "antigravity": LeadRuntimeInfo(
+        runtime="antigravity",
+        agent="antigravity",
+        agent_label="Antigravity CLI",
+        role="Antigravity lead",
+        adapter_name="antigravity",
+        adapter_dispatch_mode="render-only",
+        session_accounting="artifact-only",
+        has_claude_session=False,
+        adapter_contract_relative_path="lead/adapters/antigravity.md",
+    ),
     "external": LeadRuntimeInfo(
         runtime="external",
         agent="external",