okstra 0.136.0 → 0.138.0

package/runtime/python/okstra_ctl/codex_dispatch.py

@@ -22,92 +22,53 @@ from .final_report_paths import (
     final_report_data_path as _final_report_data_path,
     final_report_markdown_path as _final_report_markdown_path,
 )
+from .initial_prompt_materialization import (
+    InitialPromptMaterializationError,
+    InitialPromptMaterializationRequest,
+    InitialPromptWorkerRequest,
+    PromptDeliveryMode,
+    materialize_initial_prompts,
+)
 from .lead_events import LeadEvent, append_lead_event
+from .dispatch_state import (
+    BACKEND_CLI_WRAPPER,
+    BACKEND_MIXED,
+    BACKEND_TMUX_PANE,
+    DispatchError,
+    WorkerJob,
+    dispatch_mode as _dispatch_mode,
+    load_json_object as _load_json_object,
+    missing_completion_paths as _missing_completion_paths,
+    require_string as _require_string,
+    resolve_project_path as _resolve_project_path,
+    resolve_required_path as _resolve_required_path,
+    set_dispatch_mode as _set_dispatch_mode,
+    set_worker_status as _set_worker_status,
+    string_list as _string_list,
+    string_value as _string_value,
+    utc_now as _utc_now,
+    worker_state as _worker_state,
+    worktree_path as _worktree_path,
+    write_json as _write_json,
+)
 from .path_hints import hydrate_active_run_context
 from .report_finalize import (
     STEP_VALIDATE_RUN,
     FinalizeContext,
     FinalizeError,
-    project_relative_path as _project_relative_path,
-    require_string as _require_string,
     resolve_optional_path as _resolve_optional_path,
-    resolve_project_path as _resolve_project_path,
     run_finalize,
     run_seq as _run_seq,
-    string_value as _string_value,
 )
 from .wrapper_status import status_path_for_prompt
-from .worker_prompt_headers import WorkerPromptHeaderError, worker_prompt_headers
-from .worker_prompt_contract import PromptRecord, validate_initial_prompt_records
-from .worker_prompt_body import (
-    analysis_input_lines as _analysis_input_lines,
-    analysis_prompt_body as _analysis_prompt_body,
-    existing_input_lines as _existing_input_lines,
-    instruction_path as _instruction_path,
-    mcp_pointer_line as _mcp_pointer_line,
-)
-from .worker_prompt_policy import (
-    PromptPlan,
-    resolve_prompt_plan_for_manifest,
-)
+from .worker_prompt_body import REPORT_WRITER_WORKER_ID
 
 
 SUPPORTED_CLI_WORKERS = {
     "codex": "okstra-codex-exec.sh",
     "antigravity": "okstra-antigravity-exec.sh",
 }
-BACKEND_CLI_WRAPPER = "cli-wrapper"
-BACKEND_MIXED = "mixed"
 MAX_WORKER_ATTEMPTS = 2
-REPORT_WRITER_WORKER_ID = "report-writer"
-REPORT_LANGUAGE_VALUES = {"en", "ko", "auto"}
-
-
-class DispatchError(Exception):
-    """Raised when a Codex dispatch request cannot be executed."""
-
-
-@dataclass(frozen=True)
-class WorkerDispatch:
-    worker_id: str
-    backend: str
-    project_root: Path
-    model_execution_value: str
-    wrapper_path: Path
-    prompt_path: Path
-    result_path: Path
-    worker_result_path: Path
-    completion_paths: tuple[Path, ...]
-    worktree_path: str
-    role: str
-    idle_timeout_seconds: int
-
-    @property
-    def command(self) -> list[str]:
-        return [
-            str(self.wrapper_path),
-            str(self.project_root),
-            self.model_execution_value,
-            str(self.prompt_path),
-            self.worktree_path,
-            self.role,
-            str(self.idle_timeout_seconds),
-        ]
-
-    def to_payload(self) -> dict[str, Any]:
-        return {
-            "workerId": self.worker_id,
-            "backend": self.backend,
-            "modelExecutionValue": self.model_execution_value,
-            "wrapperPath": str(self.wrapper_path),
-            "promptPath": str(self.prompt_path),
-            "resultPath": str(self.result_path),
-            "workerResultPath": str(self.worker_result_path),
-            "completionPaths": [str(path) for path in self.completion_paths],
-            "worktreePath": self.worktree_path,
-            "role": self.role,
-            "command": self.command,
-        }
 
 
 @dataclass(frozen=True)
@@ -118,7 +79,7 @@ class DispatchPlan:
     team_state_path: Path
     lead_events_path: Path
     manifest: Mapping[str, Any]
-    workers: tuple[WorkerDispatch, ...]
+    workers: tuple[WorkerJob, ...]
 
     def to_payload(self, *, dry_run: bool) -> dict[str, Any]:
         return {
@@ -137,6 +98,18 @@ class DispatchPlan:
         }
 
 
+@dataclass(frozen=True)
+class _DispatchInputs:
+    project_root: Path
+    manifest_path: Path
+    manifest: Mapping[str, Any]
+    selected_workers: tuple[str, ...]
+    team_state_path: Path
+    team_state: Mapping[str, Any]
+    active_context: Mapping[str, Any]
+    lead_events_path: Path
+
+
 def build_dispatch_plan(
     *,
     project_root: Path,
@@ -148,19 +121,62 @@ def build_dispatch_plan(
     enable_codex_report_writer: bool = False,
     report_writer_codex_model: str = "",
 ) -> DispatchPlan:
+    inputs = _load_dispatch_inputs(
+        project_root,
+        run_manifest_path,
+        requested_workers,
+        enable_codex_report_writer=enable_codex_report_writer,
+    )
+    worker_requests, prompt_paths = _materialize_selected_worker_prompts(
+        project_root=inputs.project_root,
+        manifest_path=inputs.manifest_path,
+        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,
+        manifest=inputs.manifest,
+        team_state=inputs.team_state,
+        active_context=inputs.active_context,
+        workspace_root=workspace_root,
+        okstra_bin=okstra_bin,
+        idle_timeout_seconds=idle_timeout_seconds,
+        selected_workers=inputs.selected_workers,
+        worker_requests=worker_requests,
+        prompt_paths=prompt_paths,
+    )
+    return DispatchPlan(
+        project_root=inputs.project_root,
+        workspace_root=workspace_root,
+        manifest_path=inputs.manifest_path,
+        team_state_path=inputs.team_state_path,
+        lead_events_path=inputs.lead_events_path,
+        manifest=inputs.manifest,
+        workers=workers,
+    )
+
+
+def _load_dispatch_inputs(
+    project_root: Path,
+    run_manifest_path: Path,
+    requested_workers: Sequence[str],
+    *,
+    enable_codex_report_writer: bool,
+) -> _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)
-
-    selected_workers = _select_workers(
-        manifest,
-        requested_workers,
-        enable_codex_report_writer=enable_codex_report_writer,
-    )
-    team_state_path = _resolve_required_path(
-        project_root, manifest, "teamStatePath", "team-state"
+    selected_workers = tuple(
+        _select_workers(
+            manifest,
+            requested_workers,
+            enable_codex_report_writer=enable_codex_report_writer,
+        )
     )
+    team_state_path = _resolve_required_path(project_root, manifest, "teamStatePath")
     team_state = _load_json_object(team_state_path, "team-state")
     _mark_skipped_workers(
         team_state_path,
@@ -175,19 +191,67 @@ def build_dispatch_plan(
     active_context = _load_optional_json_object(
         _resolve_optional_path(project_root, manifest.get("activeRunContextPath"))
     )
-    lead_events_path = _resolve_required_path(
-        project_root, manifest, "leadEventsPath", "lead events"
-    )
-    _materialize_missing_worker_prompts(
+    return _DispatchInputs(
         project_root=project_root,
+        manifest_path=manifest_path,
         manifest=manifest,
+        selected_workers=selected_workers,
+        team_state_path=team_state_path,
         team_state=team_state,
         active_context=active_context,
-        selected_workers=selected_workers,
-        workspace_root=workspace_root,
-        report_writer_codex_model=report_writer_codex_model,
+        lead_events_path=_resolve_required_path(project_root, manifest, "leadEventsPath"),
+    )
+
+
+def _materialize_selected_worker_prompts(
+    *,
+    project_root: Path,
+    manifest_path: Path,
+    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,
+            ),
+        )
+        for worker_id in selected_workers
     )
-    workers = tuple(
+    try:
+        prompt_paths = materialize_initial_prompts(
+            InitialPromptMaterializationRequest(
+                project_root=project_root,
+                run_manifest_path=manifest_path,
+                runtime_root=workspace_root,
+                delivery_mode=PromptDeliveryMode.EAGER_INCLUDE,
+                workers=worker_requests,
+            )
+        )
+    except InitialPromptMaterializationError as exc:
+        raise DispatchError(f"{exc.reason}: {exc}") from exc
+    return worker_requests, prompt_paths
+
+
+def _build_selected_worker_dispatches(
+    *,
+    project_root: Path,
+    manifest: Mapping[str, Any],
+    team_state: Mapping[str, Any],
+    active_context: Mapping[str, Any],
+    workspace_root: Path,
+    okstra_bin: Path | None,
+    idle_timeout_seconds: int,
+    selected_workers: Sequence[str],
+    worker_requests: Sequence[InitialPromptWorkerRequest],
+    prompt_paths: Sequence[Path],
+) -> tuple[WorkerJob, ...]:
+    return tuple(
         _build_worker_dispatch(
             worker_id=worker_id,
             project_root=project_root,
@@ -197,36 +261,18 @@ def build_dispatch_plan(
             workspace_root=workspace_root,
             okstra_bin=okstra_bin,
             idle_timeout_seconds=idle_timeout_seconds,
-            report_writer_codex_model=report_writer_codex_model,
+            model_execution_value=worker_request.model,
+            prompt_path=prompt_path,
+        )
+        for worker_id, worker_request, prompt_path in zip(
+            selected_workers,
+            worker_requests,
+            prompt_paths,
+            strict=True,
         )
-        for worker_id in selected_workers
-    )
-    _validate_initial_prompts(manifest, workers)
-    return DispatchPlan(
-        project_root=project_root,
-        workspace_root=workspace_root,
-        manifest_path=manifest_path,
-        team_state_path=team_state_path,
-        lead_events_path=lead_events_path,
-        manifest=manifest,
-        workers=workers,
     )
 
 
-def _validate_initial_prompts(
-    manifest: Mapping[str, Any],
-    workers: Sequence[WorkerDispatch],
-) -> None:
-    records = [
-        PromptRecord(worker.worker_id, "initial", worker.prompt_path)
-        for worker in workers
-    ]
-    errors = validate_initial_prompt_records(manifest=manifest, records=records)
-    if errors:
-        task_type = _require_string(manifest, "taskType")
-        raise DispatchError(f"{task_type} prompt contract: " + "; ".join(errors))
-
-
 def dispatch_plan(plan: DispatchPlan) -> int:
     _set_dispatch_mode(plan.team_state_path, _dispatch_mode(plan.workers))
     for worker in plan.workers:
@@ -244,7 +290,7 @@ def dispatch_plan(plan: DispatchPlan) -> int:
     return 0
 
 
-def _dispatch_worker_with_retry(plan: DispatchPlan, worker: WorkerDispatch) -> int:
+def _dispatch_worker_with_retry(plan: DispatchPlan, worker: WorkerJob) -> int:
     for attempt in range(1, MAX_WORKER_ATTEMPTS + 1):
         _record_worker_attempt(plan, worker, attempt, "running")
         attempt_details = _attempt_event_details(worker, attempt)
@@ -305,7 +351,7 @@ def _dispatch_worker_with_retry(plan: DispatchPlan, worker: WorkerDispatch) -> i
     return 1
 def _record_worker_attempt(
     plan: DispatchPlan,
-    worker: WorkerDispatch,
+    worker: WorkerJob,
     attempt: int,
     status: str,
     reason: str = "",
@@ -327,7 +373,7 @@ def _record_worker_attempt(
 
 
 def _matches_worker_attempt(
-    record: object, worker: WorkerDispatch, attempt: int
+    record: object, worker: WorkerJob, attempt: int
 ) -> bool:
     return (
         isinstance(record, dict)
@@ -338,7 +384,7 @@ def _matches_worker_attempt(
 
 
 def _worker_dispatch_record(
-    worker: WorkerDispatch, attempt: int, status: str, reason: str
+    worker: WorkerJob, attempt: int, status: str, reason: str
 ) -> dict[str, Any]:
     provider = "codex" if worker.worker_id == REPORT_WRITER_WORKER_ID else worker.worker_id
     return {
@@ -403,147 +449,6 @@ def _parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _materialize_missing_worker_prompts(
-    *,
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    team_state: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    selected_workers: Sequence[str],
-    workspace_root: Path,
-    report_writer_codex_model: str,
-) -> None:
-    for worker_id in selected_workers:
-        prompt_path = _resolve_project_path(
-            project_root, _worker_prompt_path(manifest, worker_id)
-        )
-        if prompt_path.is_file():
-            continue
-        prompt = _render_missing_worker_prompt(
-            project_root=project_root,
-            manifest=manifest,
-            team_state=team_state,
-            active_context=active_context,
-            worker_id=worker_id,
-            workspace_root=workspace_root,
-            report_writer_codex_model=report_writer_codex_model,
-        )
-        prompt_path.parent.mkdir(parents=True, exist_ok=True)
-        prompt_path.write_text(prompt, encoding="utf-8")
-
-
-def _render_missing_worker_prompt(
-    *,
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    team_state: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    worker_id: str,
-    workspace_root: Path,
-    report_writer_codex_model: str,
-) -> str:
-    if worker_id == REPORT_WRITER_WORKER_ID:
-        return _render_missing_report_writer_prompt(
-            project_root=project_root,
-            manifest=manifest,
-            team_state=team_state,
-            active_context=active_context,
-            report_writer_codex_model=report_writer_codex_model,
-        )
-    return _render_missing_analysis_worker_prompt(
-        project_root=project_root,
-        manifest=manifest,
-        team_state=team_state,
-        active_context=active_context,
-        worker_id=worker_id,
-        workspace_root=workspace_root,
-    )
-
-
-def _render_missing_analysis_worker_prompt(
-    *,
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    team_state: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    worker_id: str,
-    workspace_root: Path,
-) -> str:
-    worker_state = _worker_state(team_state, worker_id)
-    result_rel = _require_string(worker_state, "resultPath")
-    prompt_rel = _worker_prompt_path(manifest, worker_id)
-    model = _require_string(worker_state, "modelExecutionValue")
-    role = _analysis_pane_role(manifest, active_context, worker_id)
-    plan = _initial_prompt_plan(manifest, worker_id)
-    lines = _base_prompt_headers(
-        project_root=project_root,
-        manifest=manifest,
-        active_context=active_context,
-        worker_id=worker_id,
-        prompt_rel=prompt_rel,
-        result_rel=result_rel,
-    )
-    lines.extend(_worktree_headers(manifest, active_context, role))
-    lines.extend(
-        _analysis_prompt_body(
-            manifest,
-            active_context,
-            worker_id,
-            model,
-            role,
-            plan,
-        )
-    )
-    executor_tail = _implementation_executor_tail(
-        manifest,
-        active_context,
-        project_root,
-        workspace_root,
-        role,
-    )
-    if executor_tail:
-        lines.extend(["", executor_tail.rstrip()])
-    return "\n".join(lines).rstrip() + "\n"
-
-
-def _render_missing_report_writer_prompt(
-    *,
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    team_state: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    report_writer_codex_model: str,
-) -> str:
-    worker_state = _worker_state(team_state, REPORT_WRITER_WORKER_ID)
-    markdown_path = _resolve_required_path(
-        project_root, manifest, "expectedReportPath", "report"
-    )
-    data_json_path = _final_report_data_path(markdown_path)
-    result_rel = _project_relative_path(project_root, data_json_path)
-    worker_result_rel = _require_string(worker_state, "resultPath")
-    model = (report_writer_codex_model or "").strip()
-    if not model:
-        raise DispatchError(
-            "Codex report-writer dispatch requires --report-writer-codex-model"
-        )
-    lines = _base_prompt_headers(
-        project_root=project_root,
-        manifest=manifest,
-        active_context=active_context,
-        worker_id=REPORT_WRITER_WORKER_ID,
-        prompt_rel=_worker_prompt_path(manifest, REPORT_WRITER_WORKER_ID),
-        result_rel=result_rel,
-        audit_source_rel=worker_result_rel,
-    )
-    lines.extend([
-        f"**Worker Result Path:** {worker_result_rel}",
-        f"**Model:** Report writer worker, {model}",
-        f"**Report Language:** {_resolve_report_language(project_root, manifest, active_context)}",
-    ])
-    lines.extend(_report_writer_prompt_body(manifest, active_context, team_state))
-    return "\n".join(lines).rstrip() + "\n"
-
-
 def _build_worker_dispatch(
     *,
     worker_id: str,
@@ -554,8 +459,9 @@ def _build_worker_dispatch(
     workspace_root: Path,
     okstra_bin: Path | None,
     idle_timeout_seconds: int,
-    report_writer_codex_model: str,
-) -> WorkerDispatch:
+    model_execution_value: str,
+    prompt_path: Path,
+) -> WorkerJob:
     if worker_id == REPORT_WRITER_WORKER_ID:
         return _build_report_writer_dispatch(
             project_root=project_root,
@@ -564,20 +470,19 @@ def _build_worker_dispatch(
             workspace_root=workspace_root,
             okstra_bin=okstra_bin,
             idle_timeout_seconds=idle_timeout_seconds,
-            report_writer_codex_model=report_writer_codex_model,
+            model_execution_value=model_execution_value,
+            prompt_path=prompt_path,
         )
     worker_state = _worker_state(team_state, worker_id)
-    prompt_rel = _worker_prompt_path(manifest, worker_id)
-    prompt_path = _resolve_project_path(project_root, prompt_rel)
     result_path = _resolve_project_path(
         project_root, _require_string(worker_state, "resultPath")
     )
-    model_execution_value = _require_string(worker_state, "modelExecutionValue")
     wrapper = _resolve_wrapper(worker_id, workspace_root, okstra_bin)
     worktree_path = _worktree_path(manifest, active_context)
     role = _pane_role(prompt_path)
-    return WorkerDispatch(
+    return WorkerJob(
         worker_id=worker_id,
+        provider=worker_id,
         backend=BACKEND_CLI_WRAPPER,
         project_root=project_root,
         model_execution_value=model_execution_value,
@@ -589,6 +494,7 @@ def _build_worker_dispatch(
         worktree_path=worktree_path,
         role=role,
         idle_timeout_seconds=idle_timeout_seconds,
+        dispatch_kind="initial",
     )
 
 
@@ -600,27 +506,21 @@ def _build_report_writer_dispatch(
     workspace_root: Path,
     okstra_bin: Path | None,
     idle_timeout_seconds: int,
-    report_writer_codex_model: str,
-) -> WorkerDispatch:
-    model_execution_value = (report_writer_codex_model or "").strip()
-    if not model_execution_value:
-        raise DispatchError(
-            "Codex report-writer dispatch requires --report-writer-codex-model"
-        )
+    model_execution_value: str,
+    prompt_path: Path,
+) -> WorkerJob:
     worker_state = _worker_state(team_state, REPORT_WRITER_WORKER_ID)
-    prompt_path = _resolve_project_path(
-        project_root, _worker_prompt_path(manifest, REPORT_WRITER_WORKER_ID)
-    )
     data_json_path = _final_report_data_path(
-        _resolve_required_path(project_root, manifest, "expectedReportPath", "report")
+        _resolve_required_path(project_root, manifest, "expectedReportPath")
     )
     markdown_path = _final_report_markdown_path(data_json_path)
     worker_result_path = _resolve_project_path(
         project_root, _require_string(worker_state, "resultPath")
     )
-    _replace_report_writer_model_line(prompt_path, model_execution_value)
-    return WorkerDispatch(
+    return WorkerJob(
         worker_id=REPORT_WRITER_WORKER_ID,
+        # codex 경로의 report-writer 는 claude 가 아니라 codex wrapper 로 돈다.
+        provider="codex",
         backend=BACKEND_CLI_WRAPPER,
         project_root=project_root,
         model_execution_value=model_execution_value,
@@ -636,287 +536,33 @@ def _build_report_writer_dispatch(
         worktree_path="",
         role=REPORT_WRITER_WORKER_ID,
         idle_timeout_seconds=idle_timeout_seconds,
+        dispatch_kind="initial",
     )
 
 
-def _report_writer_prompt_body(
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    team_state: Mapping[str, Any],
-) -> list[str]:
-    return [
-        "",
-        "# Report Writer Worker Dispatch",
-        "",
-        "## Role",
-        (
-            "You are the Report writer worker. Author the final-report data.json "
-            "and the worker-results audit file."
-        ),
-        "",
-        "## Task",
-        f"- Task key: `{_require_string(manifest, 'taskKey')}`",
-        f"- Task type: `{_require_string(manifest, 'taskType')}`",
-        "",
-        "## Inputs",
-        *_report_writer_input_lines(manifest, active_context, team_state),
-        "",
-        _mcp_pointer_line(),
-        "",
-        "## Output Contract",
-        "You are the author of TWO files:",
-        "- The final-report data.json at Result Path.",
-        "- The worker-results audit file at Audit sidecar path.",
-        (
-            'After writing the data.json, invoke "okstra render-final-report '
-            '<Result Path>" so the markdown sibling is rendered before you return.'
-        ),
-        "Do not return the report inline.",
-        "Copy Report Language verbatim into data.json.meta.reportLanguage.",
-    ]
-
-
-def _base_prompt_headers(
-    *,
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    worker_id: str,
-    prompt_rel: str,
-    result_rel: str,
-    audit_source_rel: str | None = None,
-) -> list[str]:
-    try:
-        return worker_prompt_headers(
-            project_root=project_root,
-            prompt_rel=prompt_rel,
-            result_rel=result_rel,
-            audit_source_rel=audit_source_rel,
-            worker_id=worker_id,
-            dispatch_kind="initial",
-            manifest=manifest,
-            active_context=active_context,
-        )
-    except WorkerPromptHeaderError as exc:
-        raise DispatchError(str(exc)) from exc
+def _validate_codex_manifest(manifest: Mapping[str, Any], path: Path) -> None:
+    if manifest.get("leadRuntime") != "codex":
+        raise DispatchError(f"run manifest is not a Codex lead run: {path}")
+    if not isinstance(manifest.get("leadEventsPath"), str):
+        raise DispatchError(f"run manifest has no leadEventsPath: {path}")
 
 
-def _initial_prompt_plan(
-    manifest: Mapping[str, Any],
+def _requested_worker_model(
     worker_id: str,
-) -> PromptPlan:
-    try:
-        return resolve_prompt_plan_for_manifest(
-            manifest=manifest,
-            worker_id=worker_id,
-            dispatch_kind="initial",
-        )
-    except ValueError as exc:
-        raise DispatchError(str(exc)) from exc
-
-
-def _report_writer_input_lines(
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
     team_state: Mapping[str, Any],
-) -> list[str]:
-    inputs = [
-        ("Task brief", _instruction_path(manifest, active_context, "taskBriefPath")),
-        ("Analysis profile", _instruction_path(manifest, active_context, "analysisProfilePath")),
-        ("Analysis material", _instruction_path(manifest, active_context, "analysisMaterialPath")),
-        ("Reference expectations", _instruction_path(manifest, active_context, "referenceExpectationsPath")),
-        ("Clarification response", _instruction_path(manifest, active_context, "clarificationResponsePath")),
-        ("Final report template", _instruction_path(manifest, active_context, "finalReportTemplatePath")),
-        ("Final report schema", _instruction_path(manifest, active_context, "finalReportSchemaPath")),
-        ("Worker results directory", _string_value(manifest.get("workerResultsDirectoryPath"))),
-    ]
-    lines = _existing_input_lines(inputs)
-    lines.extend(_analysis_worker_result_lines(team_state))
-    return lines or ["- No report-writer inputs were recorded in active-run-context."]
-
-
-def _analysis_worker_result_lines(team_state: Mapping[str, Any]) -> list[str]:
-    lines = []
-    workers = team_state.get("workers")
-    if not isinstance(workers, list):
-        return lines
-    for worker in workers:
-        if not isinstance(worker, Mapping):
-            continue
-        worker_id = worker.get("workerId")
-        if worker_id == REPORT_WRITER_WORKER_ID:
-            continue
-        result_path = _string_value(worker.get("resultPath"))
-        if result_path:
-            lines.append(f"- Analysis result ({worker_id}): `{result_path}`")
-    return lines
-
-
-def _analysis_pane_role(
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    worker_id: str,
-) -> str:
-    if _require_string(manifest, "taskType") != "implementation":
-        return "worker"
-    if _executor_provider(manifest) != worker_id:
-        return "worker"
-    worktree = _worktree_path(manifest, active_context)
-    if not worktree:
-        raise DispatchError("implementation executor prompt generation requires a worktree path")
-    return "executor"
-
-
-def _executor_provider(manifest: Mapping[str, Any]) -> str:
-    team_contract = manifest.get("teamContract")
-    if not isinstance(team_contract, Mapping):
-        return ""
-    executor = team_contract.get("executor")
-    if not isinstance(executor, Mapping):
-        return ""
-    return _string_value(executor.get("provider"))
-
-
-def _worktree_headers(
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    role: str,
-) -> list[str]:
-    task_type = _require_string(manifest, "taskType")
-    worktree = _worktree_path(manifest, active_context)
-    if task_type != "implementation" or not worktree:
-        return []
-    headers = [f"**Worktree:** {worktree}"]
-    if role == "executor":
-        headers.append(f"cwd for every mutating command: {worktree}")
-    return headers
-
-
-def _implementation_executor_tail(
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    project_root: Path,
-    workspace_root: Path,
-    role: str,
+    report_writer_codex_model: str,
 ) -> str:
-    if role != "executor" or _require_string(manifest, "taskType") != "implementation":
-        return ""
-    profiles = workspace_root / "prompts" / "profiles"
-    parts: list[str] = []
-    analysis_profile = _instruction_path(
-        manifest,
-        active_context,
-        "analysisProfilePath",
-    )
-    if not analysis_profile:
-        raise DispatchError("implementation executor profile path is missing")
-    executor_profile = (
-        _resolve_project_path(project_root, analysis_profile).parent
-        / "implementation-executor.md"
-    )
-    if not executor_profile.is_file():
-        raise DispatchError(
-            f"resolved implementation executor profile not found: {executor_profile}"
+    if worker_id != REPORT_WRITER_WORKER_ID:
+        return _require_string(
+            _worker_state(team_state, worker_id),
+            "modelExecutionValue",
         )
-    parts.append(executor_profile.read_text(encoding="utf-8"))
-    preflight_path = profiles / "_coding-conventions-preflight.md"
-    if preflight_path.is_file():
-        parts.append(preflight_path.read_text(encoding="utf-8"))
-    else:
-        parts.append("# Coding-conventions preflight\n\nApply project-local conventions before editing.")
-    diff_review_path = profiles / "_implementation-diff-review.md"
-    if diff_review_path.is_file():
-        parts.append(diff_review_path.read_text(encoding="utf-8"))
-    selfcheck_path = profiles / "_implementation-self-check.md"
-    if selfcheck_path.is_file():
-        parts.append(selfcheck_path.read_text(encoding="utf-8"))
-    parts.extend(_clarification_response_section(manifest, active_context, project_root))
-    return "\n\n".join(parts)
-
-
-def _clarification_response_section(
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-    project_root: Path,
-) -> list[str]:
-    """The user's answers, inlined for a CLI executor.
-
-    A CLI worker runs in its own process and receives only the prompt text, so
-    a path reference never reaches it. Passing the clarification response as a
-    path meant the executor implemented the pre-answer plan while the report
-    described the answers as carried in — the user answered and nothing
-    downstream acted on it.
-    """
-    relative = _instruction_path(manifest, active_context, "clarificationResponsePath")
-    if not relative:
-        return []
-    path = _resolve_project_path(project_root, relative)
-    if not path.is_file():
-        return []
-    body = path.read_text(encoding="utf-8").strip()
-    if not body:
-        return []
-    return [
-        "# Clarification answers carried in (authoritative)\n\n"
-        "The user answered these before this run. Where an answer conflicts "
-        "with the approved plan text, the answer wins — implement the answer "
-        f"and say so in your result.\n\nSource: `{relative}`\n\n{body}"
-    ]
-
-
-def _resolve_report_language(
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-) -> str:
-    for value in _report_language_candidates(project_root):
-        if value == "auto":
-            return _infer_report_language(project_root, manifest, active_context)
-        if value:
-            return value
-    return _infer_report_language(project_root, manifest, active_context)
-
-
-def _report_language_candidates(project_root: Path) -> list[str]:
-    okstra_home = Path(os.environ.get("OKSTRA_HOME") or Path.home() / ".okstra")
-    return [
-        _read_report_language(project_root / ".okstra" / "project.json", "project"),
-        _read_report_language(okstra_home / "config.json", "global"),
-    ]
-
-
-def _read_report_language(path: Path, label: str) -> str:
-    if not path.is_file():
-        return ""
-    value = _load_json_object(path, f"{label} config").get("reportLanguage")
-    if value in (None, ""):
-        return ""
-    if isinstance(value, str) and value in REPORT_LANGUAGE_VALUES:
-        return value
-    raise DispatchError(f"{label} config reportLanguage must be en, ko, or auto: {path}")
-
-
-def _infer_report_language(
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-) -> str:
-    task_brief = _instruction_path(manifest, active_context, "taskBriefPath")
-    if not task_brief:
-        return "en"
-    path = _resolve_project_path(project_root, task_brief)
-    if not path.is_file():
-        return "en"
-    text = path.read_text(encoding="utf-8", errors="replace")[:16000]
-    hangul_count = sum(1 for char in text if "\uac00" <= char <= "\ud7a3")
-    return "ko" if hangul_count >= 10 else "en"
-
-
-def _validate_codex_manifest(manifest: Mapping[str, Any], path: Path) -> None:
-    if manifest.get("leadRuntime") != "codex":
-        raise DispatchError(f"run manifest is not a Codex lead run: {path}")
-    if not isinstance(manifest.get("leadEventsPath"), str):
-        raise DispatchError(f"run manifest has no leadEventsPath: {path}")
+    model = report_writer_codex_model.strip()
+    if model:
+        return model
+    raise DispatchError(
+        "Codex report-writer dispatch requires --report-writer-codex-model"
+    )
 
 
 def _select_workers(
@@ -1066,7 +712,7 @@ def _resolve_wrapper(
 
 def _run_worker(
     plan: DispatchPlan,
-    worker: WorkerDispatch,
+    worker: WorkerJob,
 ) -> subprocess.CompletedProcess[str]:
     if worker.backend == BACKEND_CLI_WRAPPER:
         return _run_cli_wrapper_worker(plan, worker)
@@ -1075,7 +721,7 @@ def _run_worker(
 
 def _run_cli_wrapper_worker(
     plan: DispatchPlan,
-    worker: WorkerDispatch,
+    worker: WorkerJob,
 ) -> subprocess.CompletedProcess[str]:
     env = {
         **os.environ,
@@ -1093,7 +739,7 @@ def _run_cli_wrapper_worker(
 
 def _post_process_report_writer_result(
     plan: DispatchPlan,
-    worker: WorkerDispatch,
+    worker: WorkerJob,
 ) -> dict[str, Any]:
     if worker.worker_id != REPORT_WRITER_WORKER_ID:
         return {"ok": True, "reason": "", "steps": []}
@@ -1137,14 +783,7 @@ def _append_event(
     )
 
 
-def _dispatch_mode(workers: Sequence[WorkerDispatch]) -> str:
-    backends = {worker.backend for worker in workers}
-    if len(backends) == 1:
-        return next(iter(backends))
-    return BACKEND_MIXED
-
-
-def _event_details(worker: WorkerDispatch) -> dict[str, Any]:
+def _event_details(worker: WorkerJob) -> dict[str, Any]:
     return {
         "dispatchMode": worker.backend,
         "workerId": worker.worker_id,
@@ -1156,7 +795,7 @@ def _event_details(worker: WorkerDispatch) -> dict[str, Any]:
     }
 
 
-def _attempt_event_details(worker: WorkerDispatch, attempt: int) -> dict[str, Any]:
+def _attempt_event_details(worker: WorkerJob, attempt: int) -> dict[str, Any]:
     return {
         **_event_details(worker),
         "attempt": attempt,
@@ -1176,69 +815,6 @@ def _should_retry_missing_result(
     )
 
 
-def _missing_completion_paths(worker: WorkerDispatch) -> list[Path]:
-    return [path for path in worker.completion_paths if not path.is_file()]
-
-
-def _set_worker_status(
-    team_state_path: Path,
-    worker_id: str,
-    status: str,
-    reason: str,
-    *,
-    model_execution_value: str = "",
-) -> None:
-    payload = _load_json_object(team_state_path, "team-state")
-    workers = payload.get("workers")
-    if not isinstance(workers, list):
-        raise DispatchError(f"team-state workers must be an array: {team_state_path}")
-    for worker in workers:
-        if isinstance(worker, dict) and worker.get("workerId") == worker_id:
-            worker["status"] = status
-            worker["reason"] = reason
-            if model_execution_value:
-                worker["model"] = model_execution_value
-                worker["modelExecutionValue"] = model_execution_value
-            _write_json(team_state_path, payload)
-            return
-    raise DispatchError(f"team-state has no workerId={worker_id}: {team_state_path}")
-
-
-def _set_dispatch_mode(team_state_path: Path, dispatch_mode: str) -> None:
-    payload = _load_json_object(team_state_path, "team-state")
-    payload["dispatchMode"] = dispatch_mode
-    _write_json(team_state_path, payload)
-
-
-def _worker_state(team_state: Mapping[str, Any], worker_id: str) -> Mapping[str, Any]:
-    workers = team_state.get("workers")
-    if not isinstance(workers, list):
-        raise DispatchError("team-state workers must be an array")
-    for worker in workers:
-        if isinstance(worker, Mapping) and worker.get("workerId") == worker_id:
-            return worker
-    raise DispatchError(f"team-state has no workerId={worker_id}")
-
-
-def _worker_prompt_path(manifest: Mapping[str, Any], worker_id: str) -> str:
-    paths = manifest.get("workerPromptPathByWorkerId")
-    if not isinstance(paths, Mapping):
-        raise DispatchError("run manifest has no workerPromptPathByWorkerId object")
-    return _require_string(paths, worker_id)
-
-
-def _worktree_path(
-    manifest: Mapping[str, Any],
-    active_context: Mapping[str, Any],
-) -> str:
-    if manifest.get("taskType") not in {"implementation", "final-verification"}:
-        return ""
-    worktree = active_context.get("executorWorktree")
-    if not isinstance(worktree, Mapping):
-        return ""
-    return str(worktree.get("path") or "")
-
-
 def _pane_role(prompt_path: Path) -> str:
     if not prompt_path.is_file():
         raise DispatchError(f"worker prompt not found: {prompt_path}")
@@ -1250,39 +826,12 @@ def _pane_role(prompt_path: Path) -> str:
     return "worker"
 
 
-def _load_json_object(path: Path, label: str) -> dict[str, Any]:
-    if not path.is_file():
-        raise DispatchError(f"{label} not found: {path}")
-    try:
-        payload = json.loads(path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError as exc:
-        raise DispatchError(f"{label} is invalid JSON: {path}: {exc}") from exc
-    if not isinstance(payload, dict):
-        raise DispatchError(f"{label} must be a JSON object: {path}")
-    return payload
-
-
 def _load_optional_json_object(path: Path | None) -> dict[str, Any]:
     if path is None or not path.is_file():
         return {}
     return hydrate_active_run_context(_load_json_object(path, "active-run-context"))
 
 
-def _resolve_required_path(
-    project_root: Path,
-    manifest: Mapping[str, Any],
-    key: str,
-    label: str,
-) -> Path:
-    return _resolve_project_path(project_root, _require_string(manifest, key))
-
-
-def _string_list(value: Any) -> list[str]:
-    if not isinstance(value, list):
-        return []
-    return [str(item).strip() for item in value if str(item).strip()]
-
-
 def _failure_reason(exit_code: int, missing_paths: Sequence[Path]) -> str:
     if exit_code != 0:
         return f"wrapper exited with code {exit_code}"
@@ -1292,23 +841,6 @@ def _failure_reason(exit_code: int, missing_paths: Sequence[Path]) -> str:
     return "worker dispatch failed"
 
 
-def _replace_report_writer_model_line(
-    prompt_path: Path,
-    model_execution_value: str,
-) -> None:
-    if not prompt_path.is_file():
-        raise DispatchError(f"report-writer prompt not found: {prompt_path}")
-    lines = prompt_path.read_text(encoding="utf-8").splitlines()
-    marker = "**Model:** Report writer worker,"
-    replacement = f"{marker} {model_execution_value}"
-    updated = [
-        replacement if line.startswith(marker) else line
-        for line in lines
-    ]
-    if updated != lines:
-        prompt_path.write_text("\n".join(updated) + "\n", encoding="utf-8")
-
-
 def _parse_workers(raw: str) -> list[str]:
     return [item.strip() for item in raw.split(",") if item.strip()]
 
@@ -1323,20 +855,6 @@ def _parse_idle_timeout(raw: str) -> int:
     return value
 
 
-def _utc_now() -> str:
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-def _write_json(path: Path, payload: Mapping[str, Any]) -> None:
-    # Write via temp file + os.replace so a crash mid-write cannot leave a
-    # truncated team-state.json that every later _load_json_object rejects;
-    # os.replace is atomic on POSIX, matching run_context._atomic_write_json.
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
-                   encoding="utf-8")
-    os.replace(tmp, path)
-
-
 def _print_json(payload: Mapping[str, Any]) -> None:
     print(json.dumps(payload, ensure_ascii=False, indent=2))