okstra 0.207.1 → 0.209.0

package/runtime/validators/validate_analysis_report.py

@@ -174,18 +174,18 @@ def _validate_all_current_code_evidence(
 
 
 
-def _required_worker_roles(
+def _selected_worker_roles(
     run_manifest: dict, errors: list[str]
 ) -> tuple[str, ...]:
     contract = run_manifest.get("teamContract")
     entries = (
-        contract.get("requiredWorkerRoles")
+        contract.get("workerRoles")
         if isinstance(contract, dict)
         else None
     )
     if not isinstance(entries, list) or not entries:
         errors.append(
-            "run-manifest.teamContract.requiredWorkerRoles must be a non-empty "
+            "run-manifest.teamContract.workerRoles must be a non-empty "
             "array of worker contract objects"
         )
         return ()
@@ -198,13 +198,13 @@ def _required_worker_roles(
             or role != role.strip()
         ):
             errors.append(
-                "run-manifest.teamContract.requiredWorkerRoles"
+                "run-manifest.teamContract.workerRoles"
                 f"[{index}].role must be an exact non-empty string"
             )
             return ()
         if role in roles:
             errors.append(
-                "run-manifest.teamContract.requiredWorkerRoles must not contain "
+                "run-manifest.teamContract.workerRoles must not contain "
                 f"duplicate role `{role}`"
             )
             return ()
@@ -212,17 +212,17 @@ def _required_worker_roles(
     return tuple(roles)
 
 
-def _required_worker_rows(data: dict, required_roles: tuple[str, ...]) -> list[dict]:
-    required = set(required_roles)
+def _selected_worker_status_rows(data: dict, selected_roles: tuple[str, ...]) -> list[dict]:
+    selected = set(selected_roles)
     return [
         row
         for row in data.get("executionStatus") or []
-        if isinstance(row, dict) and row.get("role") in required
+        if isinstance(row, dict) and row.get("role") in selected
     ]
 
 
 def _validate_execution_status_roles(
-    data: dict, required_roles: tuple[str, ...], errors: list[str]
+    data: dict, selected_roles: tuple[str, ...], errors: list[str]
 ) -> bool:
     """Validate exact labels and report whether verdict matching is unambiguous."""
     actual_roles = {
@@ -230,7 +230,7 @@ def _validate_execution_status_roles(
         for row in data.get("executionStatus") or []
         if isinstance(row, dict)
     }
-    expected_by_fold = {role.casefold(): role for role in required_roles}
+    expected_by_fold = {role.casefold(): role for role in selected_roles}
     verdict_roles_unambiguous = True
     for actual_role in sorted(actual_roles):
         expected_role = expected_by_fold.get(actual_role.casefold())
@@ -241,10 +241,10 @@ def _validate_execution_status_roles(
             f"expected exact role `{expected_role}`"
         )
         verdict_roles_unambiguous = False
-    for required_role in required_roles:
-        if required_role in actual_roles:
+    for selected_role in selected_roles:
+        if selected_role in actual_roles:
             continue
-        errors.append(f"missing required analysis role `{required_role}`")
+        errors.append(f"missing selected analysis role `{selected_role}`")
     return verdict_roles_unambiguous
 
 
@@ -291,13 +291,13 @@ def _scope_confirmation_status(
 
 def _validate_analysis_verdict(
     data: dict,
-    required_roles: tuple[str, ...],
+    selected_roles: tuple[str, ...],
     reporter_confirmation: str | None,
     errors: list[str],
 ) -> None:
     common = data.get("analysisCommon") or {}
     scope = common.get("scope") or {}
-    worker_rows = _required_worker_rows(data, required_roles)
+    worker_rows = _selected_worker_status_rows(data, selected_roles)
     worker_blocked = not any(row.get("status") == "completed" for row in worker_rows)
     scope_blocked = reporter_confirmation != "complete"
     unresolved_review = any(
@@ -316,7 +316,7 @@ def _validate_analysis_verdict(
         return
     reasons = []
     if worker_blocked:
-        reasons.append("required analysis workers produced zero completed results")
+        reasons.append("selected analysis workers produced zero completed results")
     if scope_blocked:
         reasons.append("brief frontmatter reporter-confirmations is not complete")
     if partial:
@@ -330,7 +330,7 @@ def _validate_analysis_verdict(
 
 def _validate_scope_before_dispatch(
     data: dict,
-    required_roles: tuple[str, ...],
+    selected_roles: tuple[str, ...],
     reporter_confirmation: str | None,
     errors: list[str],
 ) -> None:
@@ -338,11 +338,11 @@ def _validate_scope_before_dispatch(
         return
     dispatched = any(
         row.get("status") != "not-run"
-        for row in _required_worker_rows(data, required_roles)
+        for row in _selected_worker_status_rows(data, selected_roles)
     )
     if dispatched:
         errors.append(
-            "required analysis workers were dispatched before "
+            "analysis workers were dispatched before "
             "reporter-confirmations: complete was recorded"
         )
 
@@ -354,9 +354,9 @@ def validate_analysis_semantics(
     reporter_confirmation: str | None,
     errors: list[str],
 ) -> None:
-    required_roles = _required_worker_roles(run_manifest, errors)
+    selected_roles = _selected_worker_roles(run_manifest, errors)
     analysis_worker_roles = tuple(
-        role for role in required_roles if not _is_report_writer_role(role)
+        role for role in selected_roles if not _is_report_writer_role(role)
     )
     verdict_roles_unambiguous = _validate_execution_status_roles(
         data, analysis_worker_roles, errors

package/runtime/python/okstra_ctl/workers.py

@@ -1,133 +0,0 @@
-"""V1 provider-worker roster compatibility parsing.
-
-Profile 파일에서 권장 worker 목록을 뽑고(`resolve_profile_workers`), 사용자
-오버라이드와 합쳐 정규화한다(`normalize_workers`). bash workers.sh 의
-동등한 python 구현.
-"""
-from __future__ import annotations
-
-from pathlib import Path
-
-from .models import provider_ids
-
-ALLOWED_WORKERS = provider_ids("analyser") + ["report-writer"]
-DEFAULT_WORKERS = ["claude", "codex", "report-writer"]
-PROFILE_BULLET_HEADERS = {
-    "- Workers:",
-    "- Required workers:",
-    "- Reviewers:",
-    "- Analysers:",
-}
-PROFILE_BULLET_HEADERS_OPTIONAL = {
-    "- Optional workers:",
-    "- Optional workers (opt-in via `--workers`):",
-}
-
-
-class WorkersError(Exception):
-    """invalid worker selection — surface to user."""
-
-
-def _resolve_v1_workers_under(profile_path: Path, headers: set[str]) -> list[str]:
-    """Read legacy provider-worker bullets without interpreting role YAML.
-
-    Collect `  - <id> …` sub-bullets under any of `headers`
-    until the next top-level bullet. Returns first token (before any
-    ` — ` / ` -- ` / whitespace) of each captured line.
-    """
-    if not Path(profile_path).is_file():
-        return []
-    capturing = False
-    out: list[str] = []
-    for line in Path(profile_path).read_text(encoding="utf-8").splitlines():
-        stripped = line.strip()
-        if stripped in headers:
-            capturing = True
-            continue
-        if not capturing:
-            continue
-        if line.startswith("- "):
-            break
-        if line.startswith("  - "):
-            body = line[4:].strip()
-            token = body.split(" — ", 1)[0].split(" -- ", 1)[0].split()[0]
-            out.append(token)
-            continue
-        if stripped:
-            break
-    return out
-
-
-def resolve_profile_workers(profile_path: Path) -> list[str]:
-    """`prompts/profiles/<task-type>.md` 본문의 `- Required workers:` (또는
-    `- Workers:` / `- Reviewers:` / `- Analysers:`) 섹션 아래 sub-bullet 들을
-    worker id 리스트로 돌려준다. profile 파일이 없거나 섹션이 없으면 빈 리스트.
-    """
-    return _resolve_v1_workers_under(profile_path, PROFILE_BULLET_HEADERS)
-
-
-def resolve_optional_workers(profile_path: Path) -> list[str]:
-    r"""`- Optional workers (opt-in via \`--workers\`):` 섹션 아래 sub-bullet
-    들에서 worker id 만 추출한다. (`  - antigravity — when added …` → `antigravity`)
-    Required 와 중복되는 항목은 제거. ALLOWED_WORKERS 밖 토큰도 제거.
-    """
-    raw = _resolve_v1_workers_under(profile_path, PROFILE_BULLET_HEADERS_OPTIONAL)
-    required = set(resolve_profile_workers(profile_path))
-    seen: set[str] = set()
-    out: list[str] = []
-    for w in raw:
-        if w in required or w in seen or w not in ALLOWED_WORKERS:
-            continue
-        seen.add(w)
-        out.append(w)
-    return out
-
-
-def normalize_workers(value: str) -> list[str]:
-    """CSV 입력을 정규화한다.
-
-    - 공백 strip, 소문자화, 중복 제거(첫 출현 우선).
-    - 빈 입력이면 `DEFAULT_WORKERS` 를 default 로 사용 (antigravity 제외).
-    - 허용 외 worker 가 포함되면 `WorkersError`.
-    """
-    items = [v.strip().lower() for v in (value or "").split(",") if v.strip()]
-    source = items or DEFAULT_WORKERS
-    unknown = [v for v in source if v not in ALLOWED_WORKERS]
-    if unknown:
-        raise WorkersError(f"unknown workers: {','.join(unknown)}")
-    seen: set[str] = set()
-    out: list[str] = []
-    for v in source:
-        if v in seen:
-            continue
-        seen.add(v)
-        out.append(v)
-    return out
-
-
-def validate_workers_against_profile(
-    workers: list[str],
-    profile_workers: list[str],
-    optional_workers: list[str] | None = None,
-) -> None:
-    """프로파일이 `Required workers:` 로 로스터를 선언했다면, 사용자
-    override 가 (required ∪ optional) 의 부분집합인지 검증한다.
-
-    `Required workers:` 는 이 시스템에서 **allowlist + 기본 로스터**다 —
-    전원 필수 집합이 아니다. 사용자는 그 안에서 좁혀 고를 수 있고(최소 1),
-    wizard 는 분석 워커만 고르게 한 뒤 report-writer 를 뒤에서 강제
-    추가하므로 누락 검증을 여기서 하면 그 흐름이 깨진다.
-
-    `profile_workers` 가 비어 있으면(프로파일이 로스터를 선언하지 않은
-    구버전) 검증을 건너뛴다.
-    """
-    if not profile_workers:
-        return
-    allowed = set(profile_workers) | set(optional_workers or [])
-    extras = [w for w in workers if w not in allowed]
-    if extras:
-        allow_str = ",".join(profile_workers + list(optional_workers or []))
-        raise WorkersError(
-            "workers not allowed by profile roster: "
-            f"{','.join(extras)} (profile allows: {allow_str})"
-        )