okstra 0.207.1 → 0.209.0

package/runtime/python/okstra_ctl/run.py

@@ -55,6 +55,12 @@ from .phases.implementation_planning.entry import (
 )
 from . import fix_cycles
 from .analysis_packet import build_analysis_packet
+from .coverage_census import (
+    CensusError,
+    census_filename,
+    census_for_run,
+    render_census_section,
+)
 from . import group_context
 from .stage_ledger import (
     build_stage_ledger,
@@ -218,13 +224,6 @@ from .session import (
 from .phases.release_handoff.entry import (
     materialize_handoff_input, resolve_pr_template,
 )
-from .worker_artifacts import worker_provider_id
-from .workers import (
-    normalize_workers,
-    resolve_optional_workers,
-    resolve_profile_workers,
-    validate_workers_against_profile,
-)
 from .workflow import compute_workflow_state, load_phase_boundary
 from .locks import worktree_provision_mutex
 from . import stage_targets as _stage_targets
@@ -528,7 +527,7 @@ def _set_data_json_approved_true_if_present(path: Path) -> bool:
 # 가 whole-task 통합 실패를 동일 타입으로 받는다. run.py 는 재노출만 한다.
 PrepareError = _stage_targets.PrepareError
 from .phases.implementation_option_selection.entry import (
-    validate_analyser_roster, validate_brief_requirements,
+    validate_brief_requirements,
 )
 
 
@@ -557,7 +556,6 @@ class PrepareInputs:
     evidence_inputs_raw: str = ""
     user_authorization_json: str = ""
     directive: str = ""
-    workers_override: str = ""
     role_counts_raw: tuple[str, ...] = ()
     role_models_raw: tuple[str, ...] = ()
     host_session_context: HostSessionContext = field(
@@ -1103,31 +1101,6 @@ def _record_artifact_runtime_render_only_event(inp: PrepareInputs, ctx: dict) ->
     )
 
 
-def _workers_flag_value(roster_csv: str) -> str:
-    """로스터 CSV 를 `--workers` 가 받는 어휘(provider id)로 되돌린다.
-
-    두 어휘가 다르다. 로스터 행은 슬롯 id(`codex-verifier`)이고 `--workers` 는
-    프로파일의 `Required workers:` 가 선언한 **provider 허용목록**이다
-    ([`workers.py`](workers.py)). 로스터를 그대로 실으면 재실행 argv 가
-    `unknown workers: codex-verifier` 로 죽는다 — 이 인자를 만드는 곳은 여기
-    하나뿐이므로 변환도 여기서 한다.
-
-    같은 provider 의 슬롯 둘은 한 항목으로 접힌다. 슬롯 수는 이 인자가 아니라
-    함께 실리는 `--role-count` · `--role-model` 이 나른다.
-    """
-    seen: set[str] = set()
-    out: list[str] = []
-    for token in (part.strip() for part in roster_csv.split(",")):
-        if not token:
-            continue
-        provider = worker_provider_id(token)
-        if provider in seen:
-            continue
-        seen.add(provider)
-        out.append(provider)
-    return ",".join(out)
-
-
 def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
     """rerun 충실 재현을 위한 canonical argv 재구성."""
     has_role_selection = bool(inp.role_counts_raw or inp.role_models_raw)
@@ -1136,9 +1109,6 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
         {} if inp.host_session_context.entry_mode == "current-session"
         else legacy_fallbacks
     )
-    workers = inp.workers_override or _workers_flag_value(
-        legacy_fallbacks.get("RECOMMENDED_ANALYSERS", "")
-    )
     pairs = [
         ("--task-type", inp.task_type),
         ("--project-id", inp.project_id),
@@ -1152,7 +1122,6 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
         ("--implementation-option", inp.implementation_option),
         ("--clarification-response", inp.clarification_response_path),
         ("--selected-direction", inp.selected_direction_path),
-        ("--workers", workers),
         (
             "--lead-provider",
             inp.lead_provider or lead_fallbacks.get("LEAD_PROVIDER", ""),
@@ -1161,19 +1130,9 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
             "--lead-model",
             inp.lead_model or lead_fallbacks.get("LEAD_MODEL", ""),
         ),
-        (
-            "--claude-model",
-            inp.claude_model or legacy_fallbacks.get("CLAUDE_WORKER_MODEL", ""),
-        ),
-        (
-            "--codex-model",
-            inp.codex_model or legacy_fallbacks.get("CODEX_WORKER_MODEL", ""),
-        ),
-        (
-            "--antigravity-model",
-            inp.antigravity_model
-            or legacy_fallbacks.get("ANTIGRAVITY_WORKER_MODEL", ""),
-        ),
+        ("--claude-model", inp.claude_model),
+        ("--codex-model", inp.codex_model),
+        ("--antigravity-model", inp.antigravity_model),
         ("--worker-model", inp.worker_models_raw),
         (
             "--report-writer-provider",
@@ -1817,36 +1776,6 @@ def _register_and_check_project(project_root: Path, inp: PrepareInputs) -> None:
         _apply_tdd_bypass_if_requested(inp, project_root)
 
 
-def _resolve_roster(inp: PrepareInputs, profile_file: Path) -> tuple[list[str], str]:
-    """profile 의 `Required workers:` 블록을 권위로 roster 를 해소한다.
-
-    release-handoff 은 의도적으로 single-lead (worker dispatch / teammate /
-    convergence 없음). profile 에 `- Required workers:` 블록이 없으므로 어떤
-    override 가 와도 빈 roster 를 강제해 profile 계약과 일관성을 유지한다."""
-    if inp.task_type == "release-handoff":
-        return [], ""
-    profile_workers = resolve_profile_workers(profile_file)
-    optional_workers = resolve_optional_workers(profile_file)
-    profile_workers_csv = ",".join(profile_workers)
-    workers = normalize_workers(inp.workers_override or profile_workers_csv)
-    if inp.workers_override.strip():
-        validate_workers_against_profile(workers, profile_workers, optional_workers)
-    try:
-        role_profile = load_role_profile(profile_file)
-    except RoleProfileError as exc:
-        raise PrepareError(str(exc)) from exc
-    requires_report_writer = any(
-        row.role == "report-writer" and row.min_count == 1
-        for row in role_profile.roles
-    )
-    if requires_report_writer and "report-writer" not in workers:
-        workers.append("report-writer")
-    if not workers:
-        raise PrepareError(f"no workers resolved for profile: {inp.task_type}")
-    _validate_option_selection_roster(inp.task_type, workers)
-    return workers, ",".join(workers)
-
-
 def _profile_requires_executor(profile_file: Path) -> bool:
     try:
         profile = load_role_profile(profile_file)
@@ -1865,21 +1794,10 @@ def _normalize_prepare_model_selection(
     try:
         _validate_critic_choice(inp.critic)
         profile = load_role_profile(profile_file)
-        profile_workers = resolve_profile_workers(profile_file)
-        has_worker_models = bool(
-            inp.worker_models_raw.strip()
-            or inp.claude_model.strip()
-            or inp.codex_model.strip()
-            or inp.antigravity_model.strip()
-        )
-        workers = inp.workers_override
-        if not workers and has_worker_models:
-            workers = ",".join(profile_workers)
         selection = normalize_model_selection_inputs(
             profile=profile,
             role_counts_raw=inp.role_counts_raw,
             role_models_raw=inp.role_models_raw,
-            workers=workers,
             worker_model=inp.worker_models_raw,
             critic=inp.critic,
             executor=inp.executor,
@@ -1925,7 +1843,6 @@ def _resolve_prepare_assignments(
     inp: PrepareInputs,
     profile: RoleProfile,
     selection: CanonicalModelSelection,
-    workers: list[str],
     lead_runtime: str,
     terminal_backend: TerminalBackend,
     requires_executor: bool,
@@ -1935,7 +1852,6 @@ def _resolve_prepare_assignments(
         inp,
         profile,
         selection,
-        workers,
         scopes,
         requires_executor,
     )
@@ -2078,7 +1994,6 @@ def _selection_provider_ids(
     inp: PrepareInputs,
     profile: RoleProfile,
     selection: CanonicalModelSelection,
-    workers: list[str],
     scopes: ModelDefaultScopes,
     requires_executor: bool,
 ) -> tuple[str, ...]:
@@ -2095,15 +2010,21 @@ def _selection_provider_ids(
             inp,
             profile,
             selection,
-            workers,
             scopes,
             default_roles,
             requires_executor,
         )
     else:
         selected = list(
-            _selected_execution_provider_ids(inp, workers, requires_executor)
+            _selected_execution_provider_ids(inp, requires_executor)
         )
+    # 스냅샷에 없는 공급자의 모델은 번들 기본값 후보에서 빠진다. 사용자가 고르지
+    # 않은 분석 칸은 등록 순서의 분석 공급자를 칸 수만큼 후보에 둔다.
+    selected.extend(
+        provider_ids("analyser")[:_bundled_analysis_default_slots(
+            profile, selection, scopes,
+        )]
+    )
     selected.extend(
         provider
         for providers in selection.provider_constraints.values()
@@ -2173,7 +2094,6 @@ def _canonical_selection_provider_ids(
     inp: PrepareInputs,
     profile: RoleProfile,
     selection: CanonicalModelSelection,
-    workers: list[str],
     scopes: ModelDefaultScopes,
     default_roles: Sequence[str],
     requires_executor: bool,
@@ -2195,27 +2115,24 @@ def _canonical_selection_provider_ids(
     if implementer_uses_bundled_default:
         # `--executor` names the provider that implements, so it belongs in the
         # roster the same way the bundled default does. Reading only the default
-        # left `--executor <provider>` with no assignment of its own: the run
-        # rendered without that provider, and asking for it with `--workers`
-        # was refused as not being in the roster.
+        # left `--executor <provider>` with no assignment of its own.
         selected.append(
             (inp.executor or "").strip().lower()
             or _default("OKSTRA_DEFAULT_EXECUTOR", "claude")
         )
-    if _needs_profile_worker_candidates(profile, selection, scopes):
-        selected.extend(
-            worker for worker in workers if worker != "report-writer"
-        )
     return selected
 
 
-def _needs_profile_worker_candidates(
+def _bundled_analysis_default_slots(
     profile: RoleProfile,
     selection: CanonicalModelSelection,
     scopes: ModelDefaultScopes,
-) -> bool:
+) -> int:
+    slots = 0
     for requirement in profile.roles:
-        if requirement.dynamic or requirement.role == "report-writer":
+        if requirement.dynamic or requirement.role in {
+            "report-writer", "implementer", "critic",
+        }:
             continue
         desired = selection.role_counts.get(
             requirement.role,
@@ -2227,8 +2144,8 @@ def _needs_profile_worker_candidates(
             or requirement.role in scopes.global_
         )
         if explicit < desired and not has_scoped_default:
-            return True
-    return False
+            slots = max(slots, desired)
+    return slots
 
 
 def _providers_from_model_refs(
@@ -2400,13 +2317,6 @@ def _read_model_defaults(path: Path) -> dict[str, tuple[str, ...]]:
     return defaults
 
 
-def _validate_option_selection_roster(task_type: str, workers: Sequence[str]) -> None:
-    if task_type == "implementation-option-selection":
-        validate_analyser_roster(workers)
-
-
-
-
 @dataclass
 class RoleAssignment:
     role: str
@@ -2530,29 +2440,6 @@ def recommended_role_models(
     return recommendations
 
 
-def _parse_worker_model_overrides(
-    raw_value: str,
-    context: AssignmentContext,
-) -> 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}")
-        context.pool.resolve_provider(provider)
-        overrides[provider] = model
-    return overrides
-
-
 def _model_for_role(
     *,
     context: AssignmentContext,
@@ -2575,209 +2462,6 @@ def _model_for_role(
         raise PrepareError(str(exc)) from exc
 
 
-def _resolve_worker_models(
-    inp: PrepareInputs,
-    workers: list[str],
-    context: AssignmentContext,
-) -> dict:
-    """Resolve provider models while preserving legacy fixed-provider projections."""
-    overrides = _parse_worker_model_overrides(inp.worker_models_raw, context)
-    legacy = {
-        "claude": inp.claude_model,
-        "codex": inp.codex_model,
-        "antigravity": inp.antigravity_model,
-    }
-    legacy_default_env = {
-        "claude": "OKSTRA_DEFAULT_CLAUDE_MODEL",
-        "codex": "OKSTRA_DEFAULT_CODEX_MODEL",
-        "antigravity": "OKSTRA_DEFAULT_ANTIGRAVITY_MODEL",
-    }
-
-    def worker_model_input(provider: str) -> str:
-        selected = overrides.get(provider, legacy.get(provider, ""))
-        env_name = legacy_default_env.get(provider)
-        return selected or (_default(env_name, "") if env_name else "")
-
-    selected_worker_providers = tuple(dict.fromkeys(
-        worker for worker in workers if worker != "report-writer"
-    ))
-    provider_models = {}
-    for provider in selected_worker_providers:
-        provider_models[provider] = _model_for_role(
-            context=context,
-            provider=provider,
-            raw_value=worker_model_input(provider),
-            role="analyser",
-        )
-    try:
-        lead_assignment = resolve_context_lead_provider(
-            context=context,
-            requested_provider=inp.lead_provider,
-        )
-    except (
-        HostCapabilityMismatch,
-        HostNotRegistered,
-        ProviderUnavailable,
-        UnknownProviderError,
-    ) as exc:
-        raise PrepareError(str(exc)) from exc
-    lead_provider = lead_assignment.provider
-    report_writer_provider = inp.report_writer_provider.strip().lower() or "claude"
-    if not context.pool.resolve_provider(report_writer_provider).supports_role(
-        "report-writer"
-    ):
-        raise PrepareError(
-            f"provider {report_writer_provider!r} does not support the report-writer role"
-        )
-
-    def legacy_projection(provider: str) -> _LegacyModelProjection:
-        assigned = provider_models.get(provider)
-        if assigned is not None:
-            return _LegacyModelProjection(
-                model_id=assigned.model_id,
-                display=assigned.display,
-                execution=assigned.execution,
-            )
-        try:
-            selected = resolve_model_selection(
-                context.pool,
-                provider,
-                "analyser",
-                worker_model_input(provider),
-            )
-        except (ValueError, RuntimeError) as exc:
-            raise PrepareError(str(exc)) from exc
-        return _LegacyModelProjection(
-            model_id=selected.model_ref.model_id,
-            display=selected.display_name,
-            execution=selected.execution_value,
-        )
-
-    return {
-        "lead_provider": lead_provider,
-        "report_writer_provider": report_writer_provider,
-        "lead": _model_for_role(
-            context=context,
-            provider=lead_provider,
-            raw_value=inp.lead_model,
-            role="leader",
-            default_override=_legacy_claude_model_override(
-                lead_provider,
-                "OKSTRA_DEFAULT_LEAD_MODEL",
-            ),
-            duty_id="lead",
-        ),
-        "cw": legacy_projection("claude"),
-        "co": legacy_projection("codex"),
-        "ge": legacy_projection("antigravity"),
-        "rw": _model_for_role(
-            context=context,
-            provider=report_writer_provider,
-            raw_value=inp.report_writer_model,
-            role="report-writer",
-            default_override=_legacy_claude_model_override(
-                report_writer_provider,
-                "OKSTRA_DEFAULT_REPORT_WRITER_MODEL",
-            ),
-        ),
-        "providers": provider_models,
-        "worker_model_inputs": {
-            provider: worker_model_input(provider)
-            for provider in dict.fromkeys((
-                *selected_worker_providers,
-                *overrides,
-                *legacy,
-            ))
-        },
-    }
-
-
-def _resolve_model_bindings(
-    inp: PrepareInputs,
-    workers: list[str],
-    context: AssignmentContext,
-    requires_executor: bool,
-) -> _ModelBindings:
-    """worker 모델 + critic 선택 + executor 바인딩을 한 묶음으로 해소·검증한다."""
-    m = _resolve_worker_models(inp, workers, context)
-    critic_choice = _validate_critic_choice(inp.critic)
-    critic_model_execution = ""
-    critic_meta = None
-    if critic_choice in provider_ids("critic"):
-        critic_meta = _model_for_role(
-            context=context,
-            provider=critic_choice,
-            raw_value=m["worker_model_inputs"].get(critic_choice, ""),
-            role="critic",
-            duty_id="scope-critic",
-        )
-        critic_model_execution = critic_meta.execution
-    executor_assignment = None
-    display_name = ""
-    if requires_executor:
-        executor_assignment, display_name = _resolve_executor_assignment(
-            inp,
-            workers,
-            context,
-            m["worker_model_inputs"],
-        )
-    lead_assignment = _role_assignment(
-        resolved=m["lead"],
-        role="lead",
-    )
-    worker_assignments = _build_worker_assignments(workers, m)
-    critic_assignment = (
-        _role_assignment(
-            resolved=critic_meta,
-            role="critic",
-        )
-        if critic_meta is not None
-        else None
-    )
-    translator_meta = _model_for_role(
-        context=context,
-        provider=m["report_writer_provider"],
-        raw_value=m["rw"].model_id,
-        role="translator",
-        duty_id="translator",
-    )
-    translator_assignment = _role_assignment(
-        resolved=translator_meta,
-        role="translator",
-    )
-    invocation_assignments = _build_invocation_assignments(
-        lead_assignment,
-        worker_assignments,
-        critic_assignment,
-        translator_assignment,
-        inp.task_type,
-    )
-    worker_by_provider = {
-        row.provider: row for row in worker_assignments
-    }
-    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_display_name=display_name,
-        codex_worker_execution=(
-            worker_by_provider["codex"].model_execution_value
-            if "codex" in worker_by_provider
-            else m["co"].execution
-        ),
-        antigravity_worker_execution=(
-            worker_by_provider["antigravity"].model_execution_value
-            if "antigravity" in worker_by_provider
-            else m["ge"].execution
-        ),
-        executor_assignment=executor_assignment,
-        lead_assignment=lead_assignment,
-        worker_assignments=worker_assignments,
-        invocation_assignments=invocation_assignments,
-        translator=translator_meta,
-    )
-
-
 def _validate_critic_choice(raw_value: str) -> str:
     """critic 은 어느 phase 에서도 opt-in 이다 — 프로필이 `min: 0` 으로 선언한다.
 
@@ -3006,12 +2690,10 @@ def _legacy_projection_from_plan(
 
 def _selected_execution_provider_ids(
     inp: PrepareInputs,
-    workers: list[str],
     requires_executor: bool,
 ) -> tuple[str, ...]:
     selected = [
         inp.lead_provider,
-        *(worker for worker in workers if worker != "report-writer"),
         inp.report_writer_provider.strip().lower() or "claude",
     ]
     critic = inp.critic.strip().lower()
@@ -3025,64 +2707,6 @@ def _selected_execution_provider_ids(
     return tuple(dict.fromkeys(selected))
 
 
-def _resolve_executor_assignment(
-    inp: PrepareInputs,
-    workers: list[str],
-    context: AssignmentContext,
-    worker_model_inputs: dict[str, str],
-) -> tuple[RoleAssignment, str]:
-    executor_default = _default("OKSTRA_DEFAULT_EXECUTOR", "claude")
-    executor_provider = (inp.executor or executor_default).strip().lower()
-    allowed_executors = provider_ids("executor")
-    if executor_provider not in allowed_executors:
-        raise PrepareError(
-            f"--executor must be one of: {', '.join(allowed_executors)} "
-            f"(got: {executor_provider!r})"
-        )
-    if executor_provider not in workers:
-        raise PrepareError(
-            f"--executor {executor_provider} requires {executor_provider!r} in "
-            f"--workers, but resolved roster is {workers!r}. "
-            f"Add it explicitly, e.g. --workers {','.join(sorted(set(workers + [executor_provider])))}."
-        )
-    model = _model_for_role(
-        context=context,
-        provider=executor_provider,
-        raw_value=worker_model_inputs.get(executor_provider, ""),
-        role="implementer",
-        duty_id="implementation-executor",
-    )
-    assignment = _role_assignment(
-        resolved=model,
-        role="executor",
-        worker_id=executor_provider,
-    )
-    display_name = (
-        f"{context.pool.resolve_provider(executor_provider).display_label} executor"
-    )
-    return assignment, display_name
-
-
-def _build_worker_assignments(
-    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
-        )
-        selected = (
-            models["rw"] if is_report_writer else models["providers"][provider]
-        )
-        assignments.append(_role_assignment(
-            resolved=selected,
-            role="report-writer" if is_report_writer else "analyser",
-            worker_id=worker_id,
-        ))
-    return tuple(assignments)
-
-
 def _role_assignment(
     *,
     resolved: ResolvedAssignment,
@@ -3138,7 +2762,7 @@ def _build_invocation_assignments(
         )
     if critic is not None:
         # 한 run 이 도달할 수 있는 critic 은 한 종류다. 둘 다 등록하면 실행될
-        # 수 없는 로스터 행이 남고, `_optional_worker_roles` 가 provider 로만
+        # 수 없는 로스터 행이 남고, `_critic_role_rows` 가 provider 로만
         # role 라벨을 만들기 때문에 두 행의 이름이 겹쳐 validate-run 이
         # `duplicate worker role detected` 로 런을 실패시킨다.
         assignments[critic_assignment_ref(task_type)] = critic.to_model_payload()
@@ -3404,11 +3028,19 @@ def _write_instruction_set_sources(
         if inp.task_type == "implementation-planning" and inp.selected_direction_path
         else ""
     )
+    from .business_flow.hooks import prepare_task_knowledge
+
+    business_knowledge = prepare_task_knowledge(
+        Path(ctx["PROJECT_ROOT"]), instruction_set, ctx,
+        (instruction_set / "task-brief.md").read_text(encoding="utf-8") + "\n" + inp.directive,
+    )
+    coverage_census_text = _write_coverage_census(inp, ctx, instruction_set)
     packet = build_analysis_packet(
         task_key=ctx["TASK_KEY"],
         task_type=ctx["TASK_TYPE"],
         task_brief_path=instruction_set / "task-brief.md",
         group_context_path=group_context_path,
+        business_knowledge_text=business_knowledge,
         analysis_profile_path=instruction_set / "analysis-profile.md",
         reference_expectations_path=instruction_set / "reference-expectations.md",
         clarification_response_path=(
@@ -3426,6 +3058,7 @@ def _write_instruction_set_sources(
             Path(ctx["PROJECT_ROOT"]), ctx["TASK_KEY"],
             json.loads(ctx.get("RELATED_TASKS_JSON", "[]")),
         ),
+        coverage_census_text=coverage_census_text,
     )
     if inp.task_type == "technical-verification":
         packet += materialize_technical_input_packet(
@@ -3441,6 +3074,46 @@ def _write_instruction_set_sources(
     return instruction_set
 
 
+def _write_coverage_census(
+    inp: PrepareInputs, ctx: dict, instruction_set: Path,
+) -> str:
+    """Persist this run's coverage census and return its packet block.
+
+    The run-scoped state file is the canonical copy because the packet lives in
+    the task-scoped instruction set and the next phase overwrites it. A profile
+    block that cannot be read is reported and the run goes on without a census.
+    """
+    changed_files: tuple[str, ...] = ()
+    if inp.task_type == "final-verification":
+        changed_files = tuple(_git_out(
+            ctx["VERIFICATION_WORKTREE_PATH"],
+            "diff",
+            "--name-only",
+            f"{ctx['VERIFICATION_BASE_REF']}..{ctx['VERIFICATION_HEAD_REF']}",
+        ).splitlines())
+    try:
+        census = census_for_run(
+            task_type=inp.task_type,
+            profile_text=(instruction_set / "analysis-profile.md").read_text(
+                encoding="utf-8"
+            ),
+            brief_path=instruction_set / "task-brief.md",
+            changed_files=changed_files,
+        )
+    except CensusError as exc:
+        print(f"prepare: coverage census skipped: {exc}", file=sys.stderr)
+        return ""
+    if census is None:
+        return ""
+    state_dir = Path(ctx["RUN_STATE_DIR"])
+    state_dir.mkdir(parents=True, exist_ok=True)
+    census_path = state_dir / census_filename(inp.task_type, ctx["RUN_STATE_SEQ"])
+    write_owned_object_atomic(census_path, census, artifact="coverage census")
+    return render_census_section(
+        census, relative_to_project_root(census_path, Path(ctx["PROJECT_ROOT"]))
+    )
+
+
 def _write_analysis_evidence_artifact(ctx: dict, instruction_set: Path) -> None:
     """Write selected evidence metadata without copying the original reports."""
     if ctx.get("TASK_TYPE") not in ANALYSIS_TASK_TYPES:
@@ -4436,7 +4109,6 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         handoff_tokens = materialize_handoff_input(
             workspace_root, project_root, inp, install_hint=_INSTALL_HINT)
 
-    workers, selected_reviewers = _resolve_roster(inp, profile_file)
     pr_template_path_str, pr_template_source = (
         resolve_pr_template(inp) if inp.task_type == "release-handoff" else ("", "")
     )
@@ -4445,7 +4117,6 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         inp=inp,
         profile=role_profile,
         selection=selection,
-        workers=workers,
         lead_runtime=lead_runtime,
         terminal_backend=terminal_backend,
         requires_executor=requires_executor,
@@ -4805,7 +4476,7 @@ bundle, and prints the rendered lead prompt without dispatching workers.
 Usage:
   okstra codex-run --project-root <dir> --project-id <id> \
     --task-group <tg> --task-id <tid> --task-type <type> \
-    --task-brief <path-or-rel> [--workers <list>] [--directive <text>] \
+    --task-brief <path-or-rel> [--directive <text>] \
     [--lead-model <m>] [--claude-model <m>] [--codex-model <m>] \
     [--antigravity-model <m>] [--report-writer-model <m>] \
     [--related-tasks <list>] [--base-ref <ref>] \
@@ -4855,7 +4526,6 @@ def build_prepare_argument_parser():
             "open + run 부착, 'no'/'' = 기록 안 함."
         ),
     )
-    p.add_argument("--workers", default="", dest="workers_override")
     p.add_argument("--role-count", action="append", default=[], dest="role_counts_raw")
     p.add_argument("--role-model", action="append", default=[], dest="role_models_raw")
     p.add_argument(
@@ -5131,7 +4801,6 @@ def main(argv: list[str]) -> int:
         evidence_inputs_raw=args.evidence_inputs_raw,
         directive=args.directive,
         user_authorization_json=args.user_authorization_json,
-        workers_override=args.workers_override,
         role_counts_raw=tuple(args.role_counts_raw),
         role_models_raw=tuple(args.role_models_raw),
         host_session_context=host_session_context,