okstra 0.167.0 → 0.169.0

package/runtime/python/okstra_ctl/codex_dispatch.py

@@ -1,114 +1,9 @@
-"""CLI-wrapper dispatcher for a Codex-hosted Okstra lead.
-
-The prepared assignment's ``runner`` field is authoritative. Native Codex
-assignments stay in the host session; this entrypoint executes only the backend
-plan returned by the worker-dispatch application use case.
-"""
+"""Compatibility alias for :mod:`okstra_ctl.worker_dispatch`."""
 from __future__ import annotations
 
-import argparse
-import json
 import sys
-from pathlib import Path
-from typing import Any, Mapping, Sequence
-
-from . import dispatch_core
-from .adapters.dispatch import with_worker_dispatch
-from .adapters.dispatch.cli_wrapper import CliWrapperDispatchPort
-from .application.dispatch_assignments import dispatch_assignments
-from .dispatch_state import DispatchError
-from .models import provider_wrappers
-from .ports.worker_dispatch import WorkerDispatchRequest
-from .registry.host_registry import default_host_registry
-
-
-SUPPORTED_CLI_WORKERS = provider_wrappers("analyser")
-
-
-def main(argv: Sequence[str] | None = None) -> int:
-    args = _parser().parse_args(argv)
-    try:
-        if args.jobs_file and args.workers:
-            raise DispatchError("--jobs-file and --workers cannot be combined")
-        request = _dispatch_request(args)
-        port = CliWrapperDispatchPort(
-            supported_worker_wrappers=SUPPORTED_CLI_WORKERS,
-            unsupported_worker_label="Codex lead",
-            required_lead_runtime="codex",
-            cli_wrapper_assignments_only=True,
-            default_provider_by_worker_id={"report-writer": "codex"},
-        )
-        host_adapter = with_worker_dispatch(
-            default_host_registry().resolve("codex"),
-            port,
-        )
-        plan = dispatch_assignments(request, host_adapter.worker_dispatch())
-        backend_plan = plan.backend_plan
-        if backend_plan is None:
-            raise DispatchError("CLI wrapper dispatch did not produce a backend plan")
-        if args.dry_run:
-            _print_json(_backend_payload(backend_plan, dry_run=True))
-            return 0
-        code = dispatch_core.dispatch_plan(backend_plan)
-        _print_json({**_backend_payload(backend_plan, dry_run=False), "exitCode": code})
-        return code
-    except DispatchError as exc:
-        print(f"error: {exc}", file=sys.stderr)
-        return 2
-
-
-def _dispatch_request(args: argparse.Namespace) -> WorkerDispatchRequest:
-    return WorkerDispatchRequest(
-        project_root=Path(args.project_root),
-        run_manifest=Path(args.run_manifest),
-        workspace_root=Path(args.workspace_root),
-        okstra_bin=Path(args.okstra_bin) if args.okstra_bin else None,
-        requested_workers=tuple(_parse_workers(args.workers)),
-        idle_timeout_seconds=_parse_idle_timeout(args.idle_timeout_seconds),
-        dispatch_kind=args.dispatch_kind,
-        jobs_file=Path(args.jobs_file) if args.jobs_file else None,
-    )
-
-
-def _backend_payload(backend_plan, *, dry_run: bool) -> dict[str, Any]:
-    payload = backend_plan.to_payload(dry_run=dry_run)
-    payload.pop("workerDispatches", None)
-    return payload
-
-
-def _parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        prog="okstra codex-dispatch",
-        description="Dispatch CLI-backed workers for a prepared Codex lead run.",
-    )
-    parser.add_argument("--project-root", required=True)
-    parser.add_argument("--run-manifest", required=True)
-    parser.add_argument("--workspace-root", required=True)
-    parser.add_argument("--okstra-bin", default="")
-    parser.add_argument("--workers", default="")
-    parser.add_argument("--dry-run", action="store_true")
-    parser.add_argument("--idle-timeout-seconds", default="600")
-    parser.add_argument("--dispatch-kind", default="initial")
-    parser.add_argument("--jobs-file", default="")
-    return parser
-
-
-def _parse_workers(raw: str) -> list[str]:
-    return [item.strip() for item in raw.split(",") if item.strip()]
-
-
-def _parse_idle_timeout(raw: str) -> int:
-    try:
-        value = int(raw)
-    except ValueError as exc:
-        raise DispatchError("--idle-timeout-seconds must be an integer") from exc
-    if value < 0:
-        raise DispatchError("--idle-timeout-seconds must be non-negative")
-    return value
-
 
-def _print_json(payload: Mapping[str, Any]) -> None:
-    print(json.dumps(payload, ensure_ascii=False, indent=2))
+from .worker_dispatch import main
 
 
 if __name__ == "__main__":

package/runtime/python/okstra_ctl/context_cost.py

@@ -25,8 +25,8 @@ INPUT_FILES = (
     "clarification-response.md",
 )
 # Per-run hot-path instruction assets the lead loads OUTSIDE the task bundle:
-# the lifecycle lead contracts (Phase 1 / 2-5 / 5.5 / 6-7) plus the worker
-# agent specs. These are the prompt-diet (perf plan v2 P2) targets; the
+# the lifecycle lead contracts (Phase 1 / 2-5 / 5.5 / 6-7) plus the host-native
+# functional agent specs. These are the prompt-diet (perf plan v2 P2) targets; the
 # bundle-local metrics below cannot see them, so they get their own metric.
 # The contracts ship as runtime resources under ~/.okstra/prompts/lead/, not
 # as agent skills.
@@ -38,9 +38,8 @@ HOT_PATH_LEAD_RESOURCES = (
 )
 WORKER_AGENT_FILES = (
     "claude-worker.md",
-    "codex-worker.md",
-    "antigravity-worker.md",
     "report-writer-worker.md",
+    "translator-worker.md",
 )
 TIMESTAMPED_ARTIFACT_RE = re.compile(r"\d{4}-\d{2}-\d{2}[_T]\d{2}-\d{2}-\d{2}")
 
@@ -114,6 +113,31 @@ def _latest_matching_file(directory: Path, pattern: str) -> Path | None:
     return max(matches, key=lambda path: path.stat().st_mtime)
 
 
+def _duty_contract_files(
+    run_dir: Path | None,
+    project_root: Path,
+    audience: str,
+) -> list[Path]:
+    if run_dir is None:
+        return []
+    manifest_path = _latest_matching_file(
+        run_dir / "manifests",
+        "run-manifest-*.json",
+    )
+    manifest = _load_json(manifest_path) if manifest_path else {}
+    contract = manifest.get("agentContract")
+    duty_root_value = (
+        contract.get("dutyRootPath")
+        if isinstance(contract, dict)
+        else None
+    )
+    if not isinstance(duty_root_value, str) or not duty_root_value:
+        return []
+    duty_root = project_root / duty_root_value
+    files = [duty_root / "common.md", duty_root / f"{audience}.md"]
+    return [path for path in files if path.is_file()]
+
+
 def _is_timestamped_legacy_artifact(path: Path) -> bool:
     return bool(TIMESTAMPED_ARTIFACT_RE.search(path.name))
 
@@ -275,12 +299,15 @@ def _lead_phase1_metric(
             files.append(team_state)
         mode = "legacy-five-file"
 
+    duty_files = _duty_contract_files(run_dir, project_root, "lead")
+    files.extend(duty_files)
     file_count, byte_count = _count_files(files)
     return {
         "mode": mode,
         "fileCount": file_count,
         "bytes": byte_count,
         "estimatedTokens": _estimate_tokens(files),
+        "dutyContractBytes": sum(_file_size(path) for path in duty_files),
         "files": [project_rel(path, project_root) for path in files if path.is_file()],
     }
 
@@ -293,6 +320,12 @@ def _analysis_worker_metric(
 ) -> dict:
     instruction_set = task_root / "instruction-set"
     full_contract_files = [instruction_set / name for name in INPUT_FILES]
+    duty_files = _duty_contract_files(
+        run_dir,
+        project_root,
+        "analysis-worker",
+    )
+    full_contract_files.extend(duty_files)
     default_preamble = (
         "implementation-worker-preamble.md"
         if task_type == "implementation"
@@ -309,7 +342,11 @@ def _analysis_worker_metric(
     legacy_packet = instruction_set / "task-packet.md"
     primary_packet = packet if packet.is_file() else legacy_packet
     has_packet = primary_packet.is_file()
-    packet_files = [primary_packet, preamble, error_contract] if has_packet else []
+    packet_files = (
+        [primary_packet, preamble, error_contract, *duty_files]
+        if has_packet
+        else []
+    )
     packet_file_count, packet_byte_count = _count_files(packet_files)
     mode = "analysis-packet-primary" if packet.is_file() else "full-input-contract"
     byte_count = packet_byte_count if packet.is_file() else full_byte_count
@@ -324,6 +361,7 @@ def _analysis_worker_metric(
         "fileCount": file_count,
         "bytesPerWorker": byte_count,
         "estimatedTokensPerWorker": _estimate_tokens(current_files),
+        "dutyContractBytes": sum(_file_size(path) for path in duty_files),
         "legacyFullContractBytesPerWorker": full_byte_count,
         "legacyFullContractFileCount": full_file_count,
         "estimatedPacketModeBytesPerWorker": packet_byte_count,
@@ -382,6 +420,8 @@ def _report_writer_metric(run_dir: Path | None, task_root: Path, project_root: P
         "report-writer-prompt-preamble.md",
     )
     files.extend((preamble, error_contract))
+    duty_files = _duty_contract_files(run_dir, project_root, "report-writer")
+    files.extend(duty_files)
     if run_dir is not None:
         files.extend(_current_seq_worker_results(run_dir))
         convergence = _latest_matching_file(
@@ -395,6 +435,7 @@ def _report_writer_metric(run_dir: Path | None, task_root: Path, project_root: P
         "fileCount": file_count,
         "bytes": byte_count,
         "estimatedTokens": _estimate_tokens(files),
+        "dutyContractBytes": sum(_file_size(path) for path in duty_files),
         "promptPreamblePath": str(preamble),
         "workerErrorContractPath": str(error_contract),
         "files": [project_rel(path, project_root) for path in files if path.is_file()],