okstra 0.174.0 → 0.176.0

package/runtime/python/okstra_ctl/run.py

@@ -26,7 +26,7 @@ import tempfile
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Sequence
+from typing import Mapping, Sequence
 
 from okstra_project import project_json_path, upsert_project_json
 from okstra_project.state import slugify
@@ -68,19 +68,44 @@ from .material import (
 from .final_report_schema import load_schema_version
 from .final_report_paths import final_report_data_path as _final_report_data_path
 from .lead_events import LeadEvent, append_lead_event
-from .application.resolve_assignment import (
-    resolve_assignment_runner,
-    resolve_lead_provider,
+from .assignment_environment import load_assignment_context
+from .assignment_resolver import (
+    AssignmentContext,
+    AssignmentPlan,
+    AssignmentResolutionError,
+    ResolvedAssignment,
+    TerminalBackend,
+    resolve_assignments,
+    resolve_context_lead_provider,
+    resolve_dispatch_assignment,
+    resolve_model_selection,
 )
 from .domain.host import (
+    CurrentSessionModelAttestation,
     HostCapabilityMismatch,
     HostNotRegistered,
+    HostSessionContext,
     ProviderUnavailable,
 )
-from .model_discovery import normalize_execution_for_dispatch
+from .domain.provider import ServedModelAttestation
+from .execution_identity import (
+    ExecutionManifest,
+    ParticipantAssignment,
+    RoleExecution,
+    execution_label,
+    model_spec_digest,
+)
+from .execution_manifest import persist_static_execution_identity
+from .legacy_model_selection import (
+    CanonicalModelSelection,
+    ModelSelectionInputError,
+    deserialize_host_session_context,
+    normalize_model_selection_inputs,
+    serialize_host_session_context,
+)
+from .model_defaults import ModelDefaultScopes
 from .worker_prompt_policy import ANALYSIS_DUTY_BY_TASK_TYPE
 from .models import (
-    ModelAssignment,
     UnknownProviderError,
     default_model,
     lead_launch_argv,
@@ -89,12 +114,11 @@ from .models import (
     provider_ids,
     provider_spec,
     provider_supports_role,
-    resolve_model_metadata,
 )
 from .schema_excerpt import build_schema_excerpt
 from .registry.host_registry import default_host_registry
 from .registry.provider_registry import default_provider_registry
-from .ports.host_model import HostModelBindingError, HostModelBindingRequest
+from .role_requirements import RoleProfile, RoleProfileError, load_role_profile
 from .agent_invocation import (
     AgentInstruction,
     AgentInstructionSource,
@@ -103,6 +127,7 @@ from .agent_invocation import (
     AgentInvocationError,
     agent_model_assignment_from_payload,
     digest_duty_catalog,
+    invocation_execution_identity_from_manifest,
     prepare_agent_invocation,
     verify_agent_invocation,
 )
@@ -422,6 +447,17 @@ class PrepareInputs:
     evidence_inputs_raw: str = ""
     directive: str = ""
     workers_override: str = ""
+    role_counts_raw: tuple[str, ...] = ()
+    role_models_raw: tuple[str, ...] = ()
+    host_session_context: HostSessionContext = field(
+        default_factory=lambda: HostSessionContext(
+            host_id="",
+            entry_mode="spawn-process",
+            available_functions=frozenset(),
+            interaction_surface="unavailable",
+            current_model=CurrentSessionModelAttestation.unknown(""),
+        )
+    )
     lead_provider: str = ""
     lead_model: str = ""
     claude_model: str = ""
@@ -706,6 +742,18 @@ def _ensure_task_directories(ctx: dict) -> None:
         Path(ctx[key]).mkdir(parents=True, exist_ok=True)
 
 
+def _role_execution_refs_from_ctx(ctx: dict) -> list[str]:
+    try:
+        payload = json.loads(ctx.get("EXECUTION_IDENTITY_JSON") or "{}")
+    except (TypeError, ValueError):
+        return []
+    return [
+        str(row.get("roleExecutionRef"))
+        for row in payload.get("roleExecutions") or []
+        if isinstance(row, dict) and row.get("roleExecutionRef")
+    ]
+
+
 def _record_start(
     *,
     workspace_root: Path,
@@ -762,6 +810,8 @@ def _record_start(
             okstra_version=ctx.get("OKSTRA_VERSION", ""),
             initial_status=initial_status,
             brief_sha256=brief_sha256,
+            execution_manifest_path=ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
+            role_execution_refs=_role_execution_refs_from_ctx(ctx),
         )
 
 
@@ -826,7 +876,15 @@ def _record_artifact_runtime_render_only_event(inp: PrepareInputs, ctx: dict) ->
 
 def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
     """rerun 충실 재현을 위한 canonical argv 재구성."""
-    workers = inp.workers_override or ctx.get("RECOMMENDED_ANALYSERS", "")
+    has_role_selection = bool(inp.role_counts_raw or inp.role_models_raw)
+    legacy_fallbacks = {} if has_role_selection else ctx
+    lead_fallbacks = (
+        {} if inp.host_session_context.entry_mode == "current-session"
+        else legacy_fallbacks
+    )
+    workers = inp.workers_override or (
+        legacy_fallbacks.get("RECOMMENDED_ANALYSERS", "")
+    )
     pairs = [
         ("--task-type", inp.task_type),
         ("--project-id", inp.project_id),
@@ -841,20 +899,44 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
         ("--clarification-response", inp.clarification_response_path),
         ("--selected-direction", inp.selected_direction_path),
         ("--workers", workers),
-        ("--lead-provider", inp.lead_provider or ctx.get("LEAD_PROVIDER", "")),
-        ("--lead-model", inp.lead_model or ctx.get("LEAD_MODEL", "")),
-        ("--claude-model", inp.claude_model or ctx.get("CLAUDE_WORKER_MODEL", "")),
-        ("--codex-model", inp.codex_model or ctx.get("CODEX_WORKER_MODEL", "")),
-        ("--antigravity-model", inp.antigravity_model or ctx.get("ANTIGRAVITY_WORKER_MODEL", "")),
+        (
+            "--lead-provider",
+            inp.lead_provider or lead_fallbacks.get("LEAD_PROVIDER", ""),
+        ),
+        (
+            "--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", ""),
+        ),
         ("--worker-model", inp.worker_models_raw),
         (
             "--report-writer-provider",
-            inp.report_writer_provider or ctx.get("REPORT_WRITER_PROVIDER", ""),
+            inp.report_writer_provider
+            or legacy_fallbacks.get("REPORT_WRITER_PROVIDER", ""),
+        ),
+        (
+            "--report-writer-model",
+            inp.report_writer_model
+            or legacy_fallbacks.get("REPORT_WRITER_MODEL", ""),
         ),
-        ("--report-writer-model", inp.report_writer_model or ctx.get("REPORT_WRITER_MODEL", "")),
         ("--lead-runtime", inp.lead_runtime if inp.lead_runtime != "claude-code" else ""),
-        ("--executor", inp.executor or ctx.get("EXECUTOR_PROVIDER", "")),
-        ("--critic", inp.critic or ctx.get("CRITIC_CHOICE", "")),
+        (
+            "--executor",
+            inp.executor or legacy_fallbacks.get("EXECUTOR_PROVIDER", ""),
+        ),
+        ("--critic", inp.critic or legacy_fallbacks.get("CRITIC_CHOICE", "")),
         ("--related-tasks", inp.related_tasks_raw),
         ("--work-category", inp.work_category),
     ]
@@ -862,6 +944,15 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
     for flag, val in pairs:
         if val:
             argv.extend([flag, val])
+    for role_count in inp.role_counts_raw:
+        argv.extend(["--role-count", role_count])
+    for role_model in inp.role_models_raw:
+        argv.extend(["--role-model", role_model])
+    if inp.host_session_context.host_id:
+        argv.extend([
+            "--host-session-context-json",
+            serialize_host_session_context(inp.host_session_context),
+        ])
     if inp.render_only:
         argv.append("--render-only")
     if not inp.plan_verification_enabled:
@@ -1686,12 +1777,487 @@ def _resolve_roster(inp: PrepareInputs, profile_file: Path) -> tuple[list[str],
     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)
+    except RoleProfileError as exc:
+        raise PrepareError(str(exc)) from exc
+    return any(
+        requirement.role == "implementer" and requirement.min_count > 0
+        for requirement in profile.roles
+    )
+
+
+def _normalize_prepare_model_selection(
+    inp: PrepareInputs,
+    profile_file: Path,
+) -> tuple[CanonicalModelSelection, RoleProfile]:
+    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,
+            lead_provider=inp.lead_provider,
+            lead_model=inp.lead_model,
+            report_writer_provider=inp.report_writer_provider,
+            report_writer_model=inp.report_writer_model,
+            provider_models={
+                "claude": inp.claude_model,
+                "codex": inp.codex_model,
+                "antigravity": inp.antigravity_model,
+            },
+        )
+    except (ModelSelectionInputError, RoleProfileError) as exc:
+        raise PrepareError(str(exc)) from exc
+    return selection, profile
+
+
+def _effective_host_session_context(
+    inp: PrepareInputs,
+    lead_runtime: str,
+) -> HostSessionContext:
+    context = inp.host_session_context
+    if context.host_id:
+        return context
+    descriptor = default_host_registry().resolve(lead_runtime).descriptor
+    current_model = context.current_model
+    if not current_model.provider_id:
+        current_model = CurrentSessionModelAttestation.unknown(
+            descriptor.native_provider_id
+        )
+    return HostSessionContext(
+        host_id=descriptor.id,
+        entry_mode=context.entry_mode,
+        available_functions=context.available_functions,
+        interaction_surface=context.interaction_surface,
+        current_model=current_model,
+    )
+
+
+def _resolve_prepare_assignments(
+    *,
+    inp: PrepareInputs,
+    profile: RoleProfile,
+    selection: CanonicalModelSelection,
+    workers: list[str],
+    lead_runtime: str,
+    terminal_backend: TerminalBackend,
+    requires_executor: bool,
+) -> tuple[AssignmentContext, AssignmentPlan]:
+    scopes = _model_default_scopes(Path(inp.project_root))
+    provider_ids_for_snapshot = _selection_provider_ids(
+        inp,
+        profile,
+        selection,
+        workers,
+        scopes,
+        requires_executor,
+    )
+    context = load_assignment_context(
+        host_runtime=lead_runtime,
+        terminal_backend=terminal_backend,
+        execution_provider_ids=provider_ids_for_snapshot,
+    )
+    host = _effective_host_session_context(inp, lead_runtime)
+    role_models = _materialize_selection_models(selection, context, host)
+    role_counts = _resolver_role_counts(profile, selection.role_counts)
+    try:
+        plan = resolve_assignments(
+            profile=profile,
+            role_counts=role_counts,
+            role_models=role_models,
+            scopes=scopes,
+            pool=context.pool,
+            host=host,
+            environment=context.environment,
+        )
+    except AssignmentResolutionError as exc:
+        raise PrepareError(_assignment_resolution_message(exc)) from exc
+    except (ValueError, RuntimeError) as exc:
+        raise PrepareError(str(exc)) from exc
+    return context, plan
+
+
+def _build_static_execution_manifest(
+    plan: AssignmentPlan,
+    context: AssignmentContext,
+    lead: ResolvedAssignment,
+) -> ExecutionManifest:
+    participants: list[ParticipantAssignment] = []
+    roles: list[RoleExecution] = []
+    assignments = (
+        lead,
+        *(row for row in plan.assignments if row.role != "leader"),
+    )
+    for index, assignment in enumerate(assignments, start=1):
+        participant_ref = f"participant-{index:03d}"
+        participants.append(_participant_assignment(assignment, participant_ref))
+        roles.append(
+            _static_role_execution(
+                assignment,
+                participant_ref,
+                context,
+            )
+        )
+    return ExecutionManifest(
+        entry_mode=lead.entry_mode,
+        participant_assignments=tuple(participants),
+        role_executions=tuple(roles),
+    )
+
+
+def _participant_assignment(
+    assignment: ResolvedAssignment,
+    participant_ref: str,
+) -> ParticipantAssignment:
+    binding = assignment.binding
+    return ParticipantAssignment(
+        participant_ref=participant_ref,
+        provider=assignment.provider_id,
+        model_ref=assignment.model_ref,
+        model_id=assignment.model_id,
+        runner=binding.runner if binding is not None else "current-session",
+        host_runtime=assignment.host_runtime,
+        host_model_value=binding.host_model_value if binding is not None else None,
+        session_ref=None,
+        window_ref=None,
+        worker_write_capability=(
+            binding.worker_write_capability if binding is not None else None
+        ),
+        entry_mode=assignment.entry_mode,
+        status="prepared",
+    )
+
+
+def _static_role_execution(
+    assignment: ResolvedAssignment,
+    participant_ref: str,
+    context: AssignmentContext,
+) -> RoleExecution:
+    binding = assignment.binding
+    digest = None
+    if assignment.model_ref is not None and binding is not None:
+        digest = model_spec_digest(context.pool.resolve(assignment.model_ref), binding)
+    return RoleExecution(
+        role_execution_ref=(
+            f"role-exec-{assignment.role}-{assignment.ordinal:03d}"
+        ),
+        participant_ref=participant_ref,
+        source_role_execution_ref=None,
+        role=assignment.role,
+        provider=assignment.provider_id,
+        model_ref=assignment.model_ref,
+        model_id=assignment.model_id,
+        ordinal=assignment.ordinal,
+        execution_label=execution_label(
+            assignment.role,
+            assignment.provider_id,
+            assignment.model_id,
+            assignment.ordinal,
+        ),
+        model_spec_digest=digest,
+        binding=binding,
+        served_model_attestation=ServedModelAttestation.unknown(),
+        status="prepared",
+    )
+
+
+def _assignment_resolution_message(exc: AssignmentResolutionError) -> str:
+    lines = [str(exc)]
+    for candidate in exc.candidates:
+        if candidate.available:
+            continue
+        lines.append(
+            f"- {candidate.role}#{candidate.ordinal} {candidate.model_ref}: "
+            f"{candidate.reason}"
+        )
+    for constraint in exc.unsatisfied_constraints:
+        lines.append(
+            f"- {constraint.role} {constraint.constraint}: "
+            f"required={constraint.required}, available={constraint.available}"
+        )
+    return "\n".join(lines)
+
+
+def _selection_provider_ids(
+    inp: PrepareInputs,
+    profile: RoleProfile,
+    selection: CanonicalModelSelection,
+    workers: list[str],
+    scopes: ModelDefaultScopes,
+    requires_executor: bool,
+) -> tuple[str, ...]:
+    default_roles = _roles_requiring_defaults(
+        inp,
+        profile,
+        selection,
+    )
+    has_canonical_role_selection = bool(
+        inp.role_counts_raw or inp.role_models_raw
+    )
+    if has_canonical_role_selection:
+        selected = _canonical_selection_provider_ids(
+            inp,
+            profile,
+            selection,
+            workers,
+            scopes,
+            default_roles,
+            requires_executor,
+        )
+    else:
+        selected = list(
+            _selected_execution_provider_ids(inp, workers, requires_executor)
+        )
+    selected.extend(
+        provider
+        for providers in selection.provider_constraints.values()
+        for provider in providers
+        if provider
+    )
+    selected.extend(_providers_from_model_refs(selection.role_models.values()))
+    selected.extend(
+        _providers_from_model_refs(
+            _selected_scoped_default_groups(default_roles, scopes)
+        )
+    )
+    current_provider = inp.host_session_context.current_model.provider_id
+    if current_provider:
+        selected.append(current_provider)
+    return tuple(dict.fromkeys(selected))
+
+
+def _selected_scoped_default_groups(
+    roles: Sequence[str],
+    scopes: ModelDefaultScopes,
+) -> tuple[tuple[str, ...], ...]:
+    groups: list[tuple[str, ...]] = []
+    for role in roles:
+        if role in scopes.project:
+            groups.append(scopes.project[role])
+        elif role in scopes.global_:
+            groups.append(scopes.global_[role])
+    return tuple(groups)
+
+
+def _roles_requiring_defaults(
+    inp: PrepareInputs,
+    profile: RoleProfile,
+    selection: CanonicalModelSelection,
+) -> tuple[str, ...]:
+    roles: list[str] = []
+    if (
+        inp.host_session_context.entry_mode != "current-session"
+        and not _explicit_selection_count(selection, "leader")
+    ):
+        roles.append("leader")
+    for requirement in profile.roles:
+        if requirement.dynamic:
+            continue
+        desired = selection.role_counts.get(
+            requirement.role,
+            requirement.recommended_count,
+        )
+        explicit = _explicit_selection_count(selection, requirement.role)
+        if explicit < desired:
+            roles.append(requirement.role)
+    return tuple(roles)
+
+
+def _explicit_selection_count(
+    selection: CanonicalModelSelection,
+    role: str,
+) -> int:
+    return max(
+        len(selection.role_models.get(role, ())),
+        len(selection.provider_constraints.get(role, ())),
+    )
+
+
+def _canonical_selection_provider_ids(
+    inp: PrepareInputs,
+    profile: RoleProfile,
+    selection: CanonicalModelSelection,
+    workers: list[str],
+    scopes: ModelDefaultScopes,
+    default_roles: Sequence[str],
+    requires_executor: bool,
+) -> list[str]:
+    selected = [inp.lead_provider]
+    report_writer_uses_bundled_default = (
+        "report-writer" in default_roles
+        and "report-writer" not in scopes.project
+        and "report-writer" not in scopes.global_
+    )
+    if report_writer_uses_bundled_default:
+        selected.append("claude")
+    implementer_uses_bundled_default = (
+        requires_executor
+        and "implementer" in default_roles
+        and "implementer" not in scopes.project
+        and "implementer" not in scopes.global_
+    )
+    if implementer_uses_bundled_default:
+        selected.append(
+            _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(
+    profile: RoleProfile,
+    selection: CanonicalModelSelection,
+    scopes: ModelDefaultScopes,
+) -> bool:
+    for requirement in profile.roles:
+        if requirement.dynamic or requirement.role == "report-writer":
+            continue
+        desired = selection.role_counts.get(
+            requirement.role,
+            requirement.recommended_count,
+        )
+        explicit = _explicit_selection_count(selection, requirement.role)
+        has_scoped_default = (
+            requirement.role in scopes.project
+            or requirement.role in scopes.global_
+        )
+        if explicit < desired and not has_scoped_default:
+            return True
+    return False
+
+
+def _providers_from_model_refs(
+    model_groups: Sequence[Sequence[str]],
+) -> tuple[str, ...]:
+    return tuple(
+        model_ref.split("/", 1)[0]
+        for models in model_groups
+        for model_ref in models
+        if "/" in model_ref
+    )
+
+
+def _materialize_selection_models(
+    selection: CanonicalModelSelection,
+    context: AssignmentContext,
+    host: HostSessionContext,
+) -> dict[str, tuple[str, ...]]:
+    role_models = dict(selection.role_models)
+    for role, providers in selection.provider_constraints.items():
+        model_values = selection.legacy_model_values.get(role, {})
+        resolved: list[str] = []
+        for raw_provider in providers:
+            provider = raw_provider or _fallback_legacy_provider(role, context, host)
+            raw_model = model_values.get(provider, model_values.get("", ""))
+            try:
+                model = resolve_model_selection(
+                    context.pool,
+                    provider,
+                    role,
+                    raw_model,
+                )
+            except (ValueError, RuntimeError) as exc:
+                raise PrepareError(str(exc)) from exc
+            resolved.append(str(model.model_ref))
+        role_models[role] = tuple(resolved)
+    return role_models
+
+
+def _fallback_legacy_provider(
+    role: str,
+    context: AssignmentContext,
+    host: HostSessionContext,
+) -> str:
+    if role == "leader":
+        return (
+            host.current_model.provider_id
+            or context.environment.host_descriptor.native_provider_id
+        )
+    return "claude"
+
+
+def _resolver_role_counts(
+    profile: RoleProfile,
+    counts: Mapping[str, int],
+) -> dict[str, int]:
+    adjustable = {
+        requirement.role
+        for requirement in profile.roles
+        if (
+            not requirement.dynamic
+            and requirement.min_count < requirement.max_count
+        )
+    }
+    return {role: count for role, count in counts.items() if role in adjustable}
+
+
+def _model_default_scopes(project_root: Path) -> ModelDefaultScopes:
+    return ModelDefaultScopes(
+        project=_read_model_defaults(project_json_path(project_root)),
+        global_=_read_model_defaults(okstra_home() / "config.json"),
+        bundled={},
+    )
+
+
+def _read_model_defaults(path: Path) -> dict[str, tuple[str, ...]]:
+    if not path.is_file():
+        return {}
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise PrepareError(f"model defaults file is invalid: {path}: {exc}") from exc
+    raw_defaults = payload.get("modelDefaults", {}) if isinstance(payload, dict) else {}
+    if not isinstance(raw_defaults, dict):
+        raise PrepareError(f"modelDefaults must be an object: {path}")
+    defaults: dict[str, tuple[str, ...]] = {}
+    for role, models in raw_defaults.items():
+        if (
+            not isinstance(role, str)
+            or not isinstance(models, list)
+            or not models
+            or not all(isinstance(model, str) and model for model in models)
+        ):
+            raise PrepareError(f"modelDefaults entries must be non-empty string arrays: {path}")
+        defaults[role] = tuple(models)
+    return defaults
+
+
 def _validate_option_selection_roster(
     task_type: str, workers: Sequence[str]
 ) -> None:
@@ -1756,23 +2322,43 @@ class _ModelBindings:
     해소한다 — prepare 가 run seq 를 할당하거나 worktree 를 만들기 전에.
     """
 
-    lead: ModelAssignment
-    cw: ModelAssignment
-    co: ModelAssignment
-    ge: ModelAssignment
-    rw: ModelAssignment
+    lead: ResolvedAssignment
+    cw: "_LegacyModelProjection"
+    co: "_LegacyModelProjection"
+    ge: "_LegacyModelProjection"
+    rw: ResolvedAssignment
     critic_choice: str
     critic_model_execution: str
     executor_display_name: str
     codex_worker_execution: str
     antigravity_worker_execution: str
-    executor_assignment: RoleAssignment
+    executor_assignment: RoleAssignment | None
     lead_assignment: RoleAssignment
     worker_assignments: tuple[RoleAssignment, ...]
     invocation_assignments: dict[str, dict[str, object]]
 
 
-def recommended_role_models(*, lead_provider: str = "") -> dict[str, str]:
+@dataclass(frozen=True)
+class _LegacyModelProjection:
+    """Display/catalog values retained for the fixed v1 manifest fields."""
+
+    model_id: str
+    display: str
+    execution: str
+
+
+def _legacy_claude_model_override(provider: str, env_name: str) -> str:
+    """Read a legacy Claude model override only for a Claude assignment."""
+    if provider.strip().lower() != "claude":
+        return ""
+    return _default(env_name, "")
+
+
+def recommended_role_models(
+    *,
+    lead_provider: str = "",
+    report_writer_provider: str = "",
+) -> dict[str, str]:
     """역할 → 추천 모델 display 값 (env override 반영). prepare 의 모델 해소와
     wizard 의 안내 표기가 공유하는 단일 기준점.
 
@@ -1782,18 +2368,28 @@ def recommended_role_models(*, lead_provider: str = "") -> dict[str, str]:
     role 별 레거시 기본값(claude 계열)으로 떨어지는데, 그 값을 codex 호스트
     화면에 그대로 쓰면 안내는 `opus` 인데 prepare 는 `gpt-5.6-sol` 을 배정한다.
     """
-    lead_default = _default(
-        "OKSTRA_DEFAULT_LEAD_MODEL",
-        provider_default_model(lead_provider, "lead")
-        if lead_provider
-        else default_model("lead"),
+    lead_provider_id = lead_provider or "claude"
+    report_writer_provider_id = report_writer_provider or "claude"
+    lead_default = (
+        _legacy_claude_model_override(
+            lead_provider_id,
+            "OKSTRA_DEFAULT_LEAD_MODEL",
+        )
+        or provider_default_model(lead_provider_id, "lead")
+    )
+    report_writer_default = (
+        _legacy_claude_model_override(
+            report_writer_provider_id,
+            "OKSTRA_DEFAULT_REPORT_WRITER_MODEL",
+        )
+        or provider_default_model(report_writer_provider_id, "report-writer")
     )
     recommendations = {
         "lead": lead_default,
         "claude": _default("OKSTRA_DEFAULT_CLAUDE_MODEL", default_model("claude")),
         "codex": _default("OKSTRA_DEFAULT_CODEX_MODEL", default_model("codex")),
         "antigravity": _default("OKSTRA_DEFAULT_ANTIGRAVITY_MODEL", default_model("antigravity")),
-        "report-writer": _default("OKSTRA_DEFAULT_REPORT_WRITER_MODEL", default_model("report-writer")),
+        "report-writer": report_writer_default,
     }
     for provider in provider_ids("analyser"):
         recommendations.setdefault(
@@ -1802,7 +2398,10 @@ def recommended_role_models(*, lead_provider: str = "") -> dict[str, str]:
     return recommendations
 
 
-def _parse_worker_model_overrides(raw_value: str) -> dict[str, str]:
+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()
@@ -1817,65 +2416,71 @@ def _parse_worker_model_overrides(raw_value: str) -> dict[str, str]:
             )
         if provider in overrides:
             raise PrepareError(f"duplicate --worker-model provider: {provider}")
-        provider_spec(provider)
+        context.pool.resolve_provider(provider)
         overrides[provider] = model
     return overrides
 
 
 def _model_for_role(
-    provider: str, raw_value: str, role: str, default_override: str = "",
-) -> ModelAssignment:
-    default_value = default_override or provider_default_model(provider, role)
-    if not default_value:
-        raise PrepareError(f"provider {provider!r} does not define a default for role {role!r}")
-    return resolve_model_metadata(
-        provider=provider,
-        raw_value=raw_value,
-        default_display=default_value,
-        default_execution=default_value,
-    )
-
-
-def _assignment_runner(lead_runtime: str, provider: str, role: str) -> str:
-    host_registry = default_host_registry()
-    provider_registry = default_provider_registry()
+    *,
+    context: AssignmentContext,
+    provider: str,
+    raw_value: str,
+    role: str,
+    default_override: str = "",
+    duty_id: str = "",
+) -> ResolvedAssignment:
     try:
-        return resolve_assignment_runner(
-            host=host_registry.resolve(lead_runtime).descriptor,
-            provider=provider_registry.resolve(provider),
+        return resolve_dispatch_assignment(
+            context=context,
+            host_runtime=context.environment.host_descriptor.id,
             role=role,
-        ).runner
-    except (
-        HostCapabilityMismatch,
-        HostNotRegistered,
-        ProviderUnavailable,
-        UnknownProviderError,
-    ) as exc:
+            duty_id=duty_id or role,
+            provider=provider,
+            model=raw_value or default_override,
+        )
+    except (ValueError, RuntimeError) as exc:
         raise PrepareError(str(exc)) from exc
 
 
-def _resolve_worker_models(inp: PrepareInputs) -> dict:
+def _resolve_worker_models(
+    inp: PrepareInputs,
+    workers: list[str],
+    context: AssignmentContext,
+) -> dict:
     """Resolve provider models while preserving legacy fixed-provider projections."""
-    rec = recommended_role_models()
-    overrides = _parse_worker_model_overrides(inp.worker_models_raw)
+    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 provider_ids("analyser"):
-        default_override = rec.get(provider, "")
+    for provider in selected_worker_providers:
         provider_models[provider] = _model_for_role(
-            provider, overrides.get(provider, legacy.get(provider, "")),
-            "analyser", default_override,
+            context=context,
+            provider=provider,
+            raw_value=worker_model_input(provider),
+            role="analyser",
         )
     try:
-        lead_assignment = resolve_lead_provider(
-            host_id=inp.lead_runtime,
+        lead_assignment = resolve_context_lead_provider(
+            context=context,
             requested_provider=inp.lead_provider,
-            host_registry=default_host_registry(),
-            provider_registry=default_provider_registry(),
         )
     except (
         HostCapabilityMismatch,
@@ -1886,119 +2491,127 @@ def _resolve_worker_models(inp: PrepareInputs) -> dict:
         raise PrepareError(str(exc)) from exc
     lead_provider = lead_assignment.provider
     report_writer_provider = inp.report_writer_provider.strip().lower() or "claude"
-    if not provider_supports_role(report_writer_provider, "report-writer"):
+    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(
-            lead_provider, inp.lead_model, "lead",
-            rec["lead"] if lead_provider == "claude" else "",
+            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": provider_models["claude"],
-        "co": provider_models["codex"],
-        "ge": provider_models["antigravity"],
+        "cw": legacy_projection("claude"),
+        "co": legacy_projection("codex"),
+        "ge": legacy_projection("antigravity"),
         "rw": _model_for_role(
-            report_writer_provider, inp.report_writer_model, "report-writer",
-            rec["report-writer"] if report_writer_provider == "claude" else "",
+            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: overrides.get(provider, legacy.get(provider, ""))
-            for provider in provider_ids("analyser")
+            provider: worker_model_input(provider)
+            for provider in dict.fromkeys((
+                *selected_worker_providers,
+                *overrides,
+                *legacy,
+            ))
         },
     }
 
 
-def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBindings:
+def _resolve_model_bindings(
+    inp: PrepareInputs,
+    workers: list[str],
+    context: AssignmentContext,
+    requires_executor: bool,
+) -> _ModelBindings:
     """worker 모델 + critic 선택 + executor 바인딩을 한 묶음으로 해소·검증한다."""
-    m = _resolve_worker_models(inp)
-    critic_choice = (inp.critic or "").strip().lower()
-    allowed_critics = ["", "off", *provider_ids("critic")]
-    if critic_choice not in allowed_critics:
-        raise PrepareError(
-            f"--critic must be one of: {', '.join(allowed_critics[1:])} "
-            f"(got: {critic_choice!r})"
-        )
+    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(
-            critic_choice,
-            m["worker_model_inputs"].get(critic_choice, ""),
-            "critic",
-        )
-        critic_model_execution = _normalized_execution(
-            critic_meta, provider=critic_choice, role="critic",
-        )
-    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 inp.task_type == "implementation" and 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])))}."
+            context=context,
+            provider=critic_choice,
+            raw_value=m["worker_model_inputs"].get(critic_choice, ""),
+            role="critic",
+            duty_id="scope-critic",
         )
-    model_meta = m["providers"][executor_provider]
-    display_name = f"{provider_spec(executor_provider).display_label} executor"
-    lead_provider = m["lead_provider"]
-    lead_execution = m["lead"].execution
-    lead_runner = _assignment_runner(inp.lead_runtime, lead_provider, "lead")
-    if lead_runner == "cli-wrapper":
-        lead_execution = _normalized_execution(
-            m["lead"], provider=lead_provider, role="lead",
+        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(
-        host_runtime=inp.lead_runtime,
+        resolved=m["lead"],
         role="lead",
-        provider=lead_provider,
-        model=m["lead"],
-        execution=lead_execution,
-        runner_role="lead",
     )
-    worker_assignments = _build_worker_assignments(inp, workers, m)
+    worker_assignments = _build_worker_assignments(workers, m)
     critic_assignment = (
         _role_assignment(
-            host_runtime=inp.lead_runtime,
+            resolved=critic_meta,
             role="critic",
-            provider=critic_choice,
-            model=critic_meta,
-            execution=critic_model_execution,
-            runner_role="critic",
         )
         if critic_meta is not None
         else None
     )
-    translator_assignment = _role_assignment(
-        host_runtime=inp.lead_runtime,
-        role="translator",
+    translator_meta = _model_for_role(
+        context=context,
         provider=m["report_writer_provider"],
-        model=m["rw"],
-        execution=_normalized_execution(
-            m["rw"],
-            provider=m["report_writer_provider"],
-            role="report-writer",
-        ),
-        runner_role="report-writer",
+        raw_value=m["rw"].model_id,
+        role="translator",
+        duty_id="translator",
     )
-    executor_assignment = _role_assignment(
-        host_runtime=inp.lead_runtime,
-        role="executor",
-        provider=executor_provider,
-        model=model_meta,
-        execution=_normalized_execution(
-            model_meta, provider=executor_provider, role="executor"
-        ),
-        runner_role="executor",
-        worker_id=executor_provider,
+    translator_assignment = _role_assignment(
+        resolved=translator_meta,
+        role="translator",
     )
     invocation_assignments = _build_invocation_assignments(
         lead_assignment,
@@ -2006,15 +2619,24 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
         critic_assignment,
         translator_assignment,
     )
+    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_execution_value(
-            m["co"], "codex", "worker", workers),
-        antigravity_worker_execution=_worker_execution_value(
-            m["ge"], "antigravity", "worker", workers),
+        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,
@@ -2022,8 +2644,245 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
     )
 
 
+def _validate_critic_choice(raw_value: str) -> str:
+    critic_choice = (raw_value or "").strip().lower()
+    allowed_critics = ["", "off", *provider_ids("critic")]
+    if critic_choice not in allowed_critics:
+        raise PrepareError(
+            f"--critic must be one of: {', '.join(allowed_critics[1:])} "
+            f"(got: {critic_choice!r})"
+        )
+    return critic_choice
+
+
+def _uses_canonical_assignment_projection(inp: PrepareInputs) -> bool:
+    return bool(
+        inp.role_counts_raw
+        or inp.role_models_raw
+        or inp.host_session_context.entry_mode == "current-session"
+    )
+
+
+def _project_assignment_plan(
+    inp: PrepareInputs,
+    plan: AssignmentPlan,
+    context: AssignmentContext,
+) -> tuple[list[str], _ModelBindings]:
+    lead = plan.by_role("leader")[0]
+    report_rows = plan.by_role("report-writer")
+    report_writer = (
+        report_rows[0]
+        if report_rows
+        else _model_for_role(
+            context=context,
+            provider=inp.report_writer_provider.strip().lower() or "claude",
+            raw_value=inp.report_writer_model,
+            role="report-writer",
+        )
+    )
+    worker_rows = tuple(
+        row for row in plan.assignments
+        if row.role not in {"leader", "critic", "implementer", "report-writer"}
+    )
+    worker_assignments = tuple(
+        _role_assignment(
+            resolved=row,
+            role=row.role,
+            worker_id=_canonical_worker_id(row, worker_rows),
+        )
+        for row in worker_rows
+    )
+    if report_rows:
+        worker_assignments = (
+            *worker_assignments,
+            _role_assignment(
+                resolved=report_writer,
+                role="report-writer",
+                worker_id="report-writer",
+            ),
+        )
+    models = _project_model_bindings(
+        inp,
+        plan,
+        context,
+        lead,
+        report_writer,
+        worker_assignments,
+    )
+    return [row.worker_id for row in worker_assignments], models
+
+
+def _canonical_worker_id(
+    assignment: ResolvedAssignment,
+    rows: Sequence[ResolvedAssignment],
+) -> str:
+    prior = sum(
+        row.provider_id == assignment.provider_id and row.ordinal < assignment.ordinal
+        for row in rows
+    )
+    return assignment.provider_id if prior == 0 else f"{assignment.provider_id}-{prior + 1}"
+
+
+def _project_model_bindings(
+    inp: PrepareInputs,
+    plan: AssignmentPlan,
+    context: AssignmentContext,
+    lead: ResolvedAssignment,
+    report_writer: ResolvedAssignment,
+    workers: tuple[RoleAssignment, ...],
+) -> _ModelBindings:
+    lead_assignment = _role_assignment(resolved=lead, role="lead")
+    critic_rows = plan.by_role("critic")
+    critic_assignment = (
+        _role_assignment(resolved=critic_rows[0], role="critic")
+        if critic_rows
+        else None
+    )
+    executor_rows = plan.by_role("implementer")
+    executor_assignment = (
+        _role_assignment(
+            resolved=executor_rows[0],
+            role="executor",
+            worker_id=executor_rows[0].provider_id,
+        )
+        if executor_rows
+        else None
+    )
+    translator = _model_for_role(
+        context=context,
+        provider=report_writer.provider_id,
+        raw_value=report_writer.model_id,
+        role="translator",
+        duty_id="translator",
+    )
+    projections = {
+        provider: _legacy_projection_from_plan(provider, plan, context)
+        for provider in ("claude", "codex", "antigravity")
+    }
+    invocation_assignments = _build_invocation_assignments(
+        lead_assignment,
+        workers,
+        critic_assignment,
+        _role_assignment(resolved=translator, role="translator"),
+    )
+    worker_by_provider = {row.provider: row for row in workers}
+    return _ModelBindings(
+        lead=lead,
+        cw=projections["claude"],
+        co=projections["codex"],
+        ge=projections["antigravity"],
+        rw=report_writer,
+        critic_choice=(critic_rows[0].provider_id if critic_rows else "off"),
+        critic_model_execution=(
+            critic_assignment.model_execution_value if critic_assignment else ""
+        ),
+        executor_display_name=(
+            f"{executor_rows[0].display_name} executor" if executor_rows else ""
+        ),
+        codex_worker_execution=(
+            worker_by_provider["codex"].model_execution_value
+            if "codex" in worker_by_provider
+            else projections["codex"].execution
+        ),
+        antigravity_worker_execution=(
+            worker_by_provider["antigravity"].model_execution_value
+            if "antigravity" in worker_by_provider
+            else projections["antigravity"].execution
+        ),
+        executor_assignment=executor_assignment,
+        lead_assignment=lead_assignment,
+        worker_assignments=workers,
+        invocation_assignments=invocation_assignments,
+    )
+
+
+def _legacy_projection_from_plan(
+    provider: str,
+    plan: AssignmentPlan,
+    context: AssignmentContext,
+) -> _LegacyModelProjection:
+    selected = next(
+        (
+            row for row in plan.assignments
+            if row.provider_id == provider and row.role != "leader"
+        ),
+        None,
+    )
+    if selected is not None:
+        return _LegacyModelProjection(
+            selected.model_id,
+            selected.display_name,
+            selected.execution,
+        )
+    model = resolve_model_selection(context.pool, provider, "analyser", "")
+    return _LegacyModelProjection(
+        model.model_ref.model_id,
+        model.display_name,
+        model.execution_value,
+    )
+
+
+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()
+    if critic not in {"", "off"}:
+        selected.append(critic)
+    if requires_executor:
+        selected.append(
+            inp.executor.strip().lower()
+            or _default("OKSTRA_DEFAULT_EXECUTOR", "claude")
+        )
+    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(
-    inp: PrepareInputs, workers: list[str], models: dict,
+    workers: list[str], models: dict,
 ) -> tuple[RoleAssignment, ...]:
     assignments: list[RoleAssignment] = []
     for worker_id in workers:
@@ -2031,18 +2890,12 @@ def _build_worker_assignments(
         provider = (
             models["report_writer_provider"] if is_report_writer else worker_id
         )
-        role = "report-writer" if is_report_writer else "analyser"
-        meta = models["rw"] if is_report_writer else models["providers"][provider]
-        execution = _worker_execution_value(
-            meta, provider, "worker", [provider],
+        selected = (
+            models["rw"] if is_report_writer else models["providers"][provider]
         )
         assignments.append(_role_assignment(
-            host_runtime=inp.lead_runtime,
-            role=role,
-            provider=provider,
-            model=meta,
-            execution=execution,
-            runner_role=role,
+            resolved=selected,
+            role="report-writer" if is_report_writer else "analyser",
             worker_id=worker_id,
         ))
     return tuple(assignments)
@@ -2050,55 +2903,40 @@ def _build_worker_assignments(
 
 def _role_assignment(
     *,
-    host_runtime: str,
+    resolved: ResolvedAssignment,
     role: str,
-    provider: str,
-    model: ModelAssignment,
-    execution: str,
-    runner_role: str,
     worker_id: str = "",
 ) -> RoleAssignment:
-    runner = _assignment_runner(host_runtime, provider, runner_role)
-    host_model_value = _resolve_host_model_value(
-        host_runtime=host_runtime,
-        provider=provider,
-        model=model,
-        execution=execution,
-        runner=runner,
-    )
+    binding = resolved.binding
+    if binding is None:
+        if resolved.role != "leader" or resolved.entry_mode != "current-session":
+            raise PrepareError("legacy assignment projection requires a model binding")
+        return RoleAssignment(
+            role=role,
+            provider=resolved.provider_id,
+            model_display=resolved.display_name,
+            model_execution_value="unknown",
+            runner="cli-wrapper",
+            host_runtime=resolved.host_runtime,
+            host_model_value=None,
+            worker_id=worker_id,
+        )
     return RoleAssignment(
         role=role,
-        provider=provider,
-        model_display=model.display,
-        model_execution_value=execution,
-        runner=runner,
-        host_runtime=host_runtime,
-        host_model_value=host_model_value,
+        provider=resolved.provider_id,
+        model_display=resolved.display_name,
+        model_execution_value=binding.resolved_execution_value,
+        runner=(
+            "native-session"
+            if binding.runner == "current-session"
+            else binding.runner
+        ),
+        host_runtime=resolved.host_runtime,
+        host_model_value=binding.host_model_value,
         worker_id=worker_id,
     )
 
 
-def _resolve_host_model_value(
-    *,
-    host_runtime: str,
-    provider: str,
-    model: ModelAssignment,
-    execution: str,
-    runner: str,
-) -> str | None:
-    try:
-        port = default_host_registry().resolve(host_runtime).host_model()
-        return port.resolve(HostModelBindingRequest(
-            host_runtime=host_runtime,
-            provider=provider,
-            model=model.display,
-            model_execution_value=execution,
-            runner=runner,
-        ))
-    except (HostModelBindingError, HostNotRegistered) as exc:
-        raise PrepareError(str(exc)) from exc
-
-
 def _build_invocation_assignments(
     lead: RoleAssignment,
     workers: tuple[RoleAssignment, ...],
@@ -2120,27 +2958,6 @@ def _build_invocation_assignments(
     return assignments
 
 
-def _normalized_execution(meta: ModelAssignment, provider: str, role: str) -> str:
-    """Route a role's catalog execution value through the CLI-identity normalizer
-    so the manifest carries the dispatch-correct spelling. SSOT for the mapping
-    lives in model_discovery; this is only the run.py call seam."""
-    return normalize_execution_for_dispatch(
-        provider=provider, execution=meta.execution, role=role,
-    )
-
-
-def _worker_execution_value(
-    meta: ModelAssignment, provider: str, role: str, workers: list[str],
-) -> str:
-    """Normalize a worker role's execution value only when that provider's
-    worker is in the resolved roster; otherwise return the raw catalog value.
-    A worker that will not be dispatched must not probe its CLI or hard-fail
-    the whole prep (the CLI-identity check belongs only to workers that run)."""
-    if provider in workers:
-        return _normalized_execution(meta, provider=provider, role=role)
-    return meta.execution
-
-
 StageRunClaim = _implementation_stage.StageRunClaim
 
 
@@ -2529,11 +3346,18 @@ def _render_lead_prompt_and_snapshot(
     assignment = _agent_model_assignment(
         json.loads(ctx["INVOCATION_ASSIGNMENTS_JSON"])["lead"]
     )
+    identity = invocation_execution_identity_from_manifest(
+        json.loads(Path(ctx["RUN_MANIFEST_PATH"]).read_text(encoding="utf-8")),
+        assignment=assignment,
+        assignment_ref="lead",
+        duty_id="lead",
+    )
+    if identity is None:
+        raise PrepareError("lead v2 execution identity is missing")
+    invocation_id = f"{ctx['TASK_TYPE_SEGMENT']}-{ctx['RUN_PROMPTS_SEQ']}-lead"
     prepared = prepare_agent_invocation(AgentInvocationRequest(
-        invocation_id=(
-            f"{ctx['TASK_TYPE_SEGMENT']}-{ctx['RUN_PROMPTS_SEQ']}-lead"
-        ),
-        worker_id="lead",
+        invocation_id=invocation_id,
+        worker_id=None,
         audience="lead",
         assignment_ref="lead",
         purpose=None,
@@ -2557,6 +3381,11 @@ def _render_lead_prompt_and_snapshot(
         prompt_path=Path(ctx["RUN_PROMPT_SNAPSHOT_FILE"]),
         metadata_path=Path(ctx["LEAD_PROMPT_METADATA_PATH"]),
         dispatch_kind="lead",
+        participant_ref=identity.participant_ref,
+        role_execution_ref=identity.role_execution_ref,
+        duty_id=identity.duty_id,
+        invocation_ref=invocation_id,
+        attempt=1,
     ))
     return prepared.prompt_path.read_text(encoding="utf-8")
 
@@ -2581,12 +3410,7 @@ def _persist_run_inputs(
         if inp.approved_plan_path
         else ""
     )
-    run_inputs_path = write_run_inputs(
-        project_root=Path(inp.project_root),
-        run_manifests_dir=Path(ctx["RUN_MANIFESTS_DIR"]),
-        task_type_segment=ctx["TASK_TYPE_SEGMENT"],
-        seq=ctx["RUN_MANIFESTS_SEQ"],
-        inputs={
+    inputs = {
             "taskBriefPath": brief_relative,
             "taskBriefAbsolutePath": str(inp.brief_path),
             "directive": inp.directive,
@@ -2608,7 +3432,11 @@ def _persist_run_inputs(
                 inp.report_writer_provider or "claude",
             ),
             "reportWriterModel": models.rw.display,
-            "executor": models.executor_assignment.provider,
+            "executor": (
+                models.executor_assignment.provider
+                if models.executor_assignment is not None
+                else ""
+            ),
             "relatedTasks": inp.related_tasks_raw,
             "approvedPlanPath": approved_plan_path,
             "clarificationResponsePath": inp.clarification_response_path,
@@ -2618,7 +3446,13 @@ def _persist_run_inputs(
             ),
             "evidenceInputs": json.loads(ctx.get("EVIDENCE_INPUTS_JSON", "[]")),
             "renderOnly": inp.render_only,
-        },
+    }
+    run_inputs_path = _write_run_inputs_once(
+        project_root=Path(inp.project_root),
+        run_manifests_dir=Path(ctx["RUN_MANIFESTS_DIR"]),
+        task_type_segment=ctx["TASK_TYPE_SEGMENT"],
+        seq=ctx["RUN_MANIFESTS_SEQ"],
+        inputs=inputs,
     )
     ctx["RUN_INPUTS_PATH"] = str(run_inputs_path)
     ctx["RUN_INPUTS_RELATIVE_PATH"] = relative_to_project_root(
@@ -2626,6 +3460,29 @@ def _persist_run_inputs(
     )
 
 
+def _write_run_inputs_once(
+    *,
+    project_root: Path,
+    run_manifests_dir: Path,
+    task_type_segment: str,
+    seq: str,
+    inputs: dict,
+) -> Path:
+    path = run_manifests_dir / f"run-inputs-{task_type_segment}-{seq}.json"
+    existing = _read_existing_manifest(path)
+    if existing.get("schemaVersion") == "2.0":
+        if existing.get("inputs") != inputs:
+            raise PrepareError("input snapshot is immutable after v2 creation")
+        return path
+    return write_run_inputs(
+        project_root=project_root,
+        run_manifests_dir=run_manifests_dir,
+        task_type_segment=task_type_segment,
+        seq=seq,
+        inputs=inputs,
+    )
+
+
 def _persist_pre_dispatch_run_manifest(ctx: dict) -> None:
     """Publish and re-read the complete invocation authority before prompts."""
     render_run_manifest(ctx["RUN_MANIFEST_PATH"], ctx)
@@ -3023,24 +3880,38 @@ def _model_ctx(models: "_ModelBindings") -> dict[str, str]:
             ),
             "",
         ),
-        "EXECUTOR_WORKER_ID": models.executor_assignment.worker_id,
-        "EXECUTOR_PROVIDER": models.executor_assignment.provider,
+        **_executor_model_ctx(models),
+        "CRITIC_CHOICE": models.critic_choice,
+        "CRITIC_MODEL_EXECUTION_VALUE": models.critic_model_execution,
+    }
+
+
+def _executor_model_ctx(models: "_ModelBindings") -> dict[str, str]:
+    assignment = models.executor_assignment
+    if assignment is None:
+        return {
+            "EXECUTOR_WORKER_ID": "",
+            "EXECUTOR_PROVIDER": "",
+            "EXECUTOR_DISPLAY_NAME": "",
+            "EXECUTOR_MODEL_DISPLAY": "",
+            "EXECUTOR_MODEL_EXECUTION_VALUE": "",
+            "EXECUTOR_HOST_MODEL_VALUE": "",
+            "EXECUTOR_RUNNER": "",
+            "EXECUTOR_DISPATCH_MODE": "",
+        }
+    return {
+        "EXECUTOR_WORKER_ID": assignment.worker_id,
+        "EXECUTOR_PROVIDER": assignment.provider,
         "EXECUTOR_DISPLAY_NAME": models.executor_display_name,
-        "EXECUTOR_MODEL_DISPLAY": models.executor_assignment.model_display,
-        "EXECUTOR_MODEL_EXECUTION_VALUE": (
-            models.executor_assignment.model_execution_value
-        ),
-        "EXECUTOR_HOST_MODEL_VALUE": (
-            models.executor_assignment.host_model_value or ""
-        ),
-        "EXECUTOR_RUNNER": models.executor_assignment.runner,
+        "EXECUTOR_MODEL_DISPLAY": assignment.model_display,
+        "EXECUTOR_MODEL_EXECUTION_VALUE": assignment.model_execution_value,
+        "EXECUTOR_HOST_MODEL_VALUE": assignment.host_model_value or "",
+        "EXECUTOR_RUNNER": assignment.runner,
         "EXECUTOR_DISPATCH_MODE": (
             "host-native"
-            if models.executor_assignment.runner == "native-session"
+            if assignment.runner == "native-session"
             else "worker-dispatch"
         ),
-        "CRITIC_CHOICE": models.critic_choice,
-        "CRITIC_MODEL_EXECUTION_VALUE": models.critic_model_execution,
     }
 
 
@@ -3147,6 +4018,8 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     # 조립 코드가 단일 흐름으로 읽히도록 유지한다.
     assets = _resolve_runtime_assets(workspace_root, inp)
     profile_file = assets.profile_file
+    requires_executor = _profile_requires_executor(profile_file)
+    selection, role_profile = _normalize_prepare_model_selection(inp, profile_file)
     prompt_template = assets.prompt_template
     task_index_template = assets.task_index_template
     final_report_template = assets.final_report_template
@@ -3168,13 +4041,45 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         handoff_tokens = _materialize_release_handoff_input(
             workspace_root, project_root, inp)
 
-    verify_installation(workspace_root)
-    _register_and_check_project(project_root, inp)
-
     workers, selected_reviewers = _resolve_roster(inp, profile_file)
     pr_template_path_str, pr_template_source = _resolve_pr_template(inp)
 
-    models = _resolve_model_bindings(inp, workers)
+    assignment_context, assignment_plan = _resolve_prepare_assignments(
+        inp=inp,
+        profile=role_profile,
+        selection=selection,
+        workers=workers,
+        lead_runtime=lead_runtime,
+        terminal_backend=terminal_backend,
+        requires_executor=requires_executor,
+    )
+    if _uses_canonical_assignment_projection(inp):
+        workers, models = _project_assignment_plan(
+            inp,
+            assignment_plan,
+            assignment_context,
+        )
+        selected_reviewers = ",".join(workers)
+    else:
+        models = _resolve_model_bindings(
+            inp,
+            workers,
+            assignment_context,
+            requires_executor,
+        )
+    execution_manifest = _build_static_execution_manifest(
+        assignment_plan,
+        assignment_context,
+        models.lead,
+    )
+    dynamic_roles = tuple(
+        requirement.role
+        for requirement in role_profile.roles
+        if requirement.dynamic
+    )
+
+    verify_installation(workspace_root)
+    _register_and_check_project(project_root, inp)
 
     # ---- paths under per-task mutex (writes run-context-*.json) ----
     # OKSTRA_RUN_SEQ_OVERRIDE: okstra-ctl rerun / 테스트 hook 이 미리 reserve
@@ -3327,6 +4232,12 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "LATEST_REPORT_RELATIVE_PATH": "",
         "RENDER_ONLY": "true" if inp.render_only else "false",
         "OKSTRA_VERSION": installed_version(),
+        "EXECUTION_IDENTITY_JSON": json.dumps(
+            execution_manifest.to_payload(), ensure_ascii=False,
+        ),
+        "DYNAMIC_EXECUTION_ROLES_JSON": json.dumps(
+            dynamic_roles, ensure_ascii=False,
+        ),
     })
     refresh_run_context_snapshot(ctx)
     if lead_runtime == "codex":
@@ -3366,6 +4277,15 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     _finalize_status_and_render_manifests(
         inp, ctx, task_index_template, forbidden_by_phase
     )
+    persist_static_execution_identity(
+        run_manifest_path=Path(ctx["RUN_MANIFEST_PATH"]),
+        task_manifest_path=Path(ctx["TASK_MANIFEST_PATH"]),
+        input_snapshot_path=Path(ctx["RUN_INPUTS_PATH"]),
+        manifest=execution_manifest,
+        task_key=ctx["TASK_KEY"],
+        run_ref=ctx["RUN_MANIFEST_RELATIVE_PATH"],
+        dynamic_roles=dynamic_roles,
+    )
     _record_artifact_runtime_render_only_event(inp, ctx)
 
     _record_run_in_central_index(inp, ctx, workspace_root, run_seq_override)
@@ -3389,10 +4309,8 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     )
 
 
-def main(argv: list[str]) -> int:
-    """CLI dispatcher for bash thin-wrapper use. Parses a flat list of argv
-    (the same flags `okstra.sh` accepts), runs prepare_task_bundle, prints
-    summary lines + prompt to stdout."""
+def build_prepare_argument_parser():
+    """Build the shared flat-argument parser used by public prepare shims."""
     import argparse
 
     p = argparse.ArgumentParser()
@@ -3422,6 +4340,13 @@ def main(argv: list[str]) -> int:
         ),
     )
     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(
+        "--host-session-context-json",
+        default="",
+        dest="host_session_context_json",
+    )
     p.add_argument("--lead-provider", default="")
     p.add_argument("--lead-model", default="")
     p.add_argument("--claude-model", default="")
@@ -3565,7 +4490,12 @@ def main(argv: list[str]) -> int:
             "`main` / `dev` / `staging` / `preprod` / `prod` or any local ref."
         ),
     )
-    args = p.parse_args(argv)
+    return p
+
+
+def main(argv: list[str]) -> int:
+    """Parse one public prepare invocation and emit its rendered bundle."""
+    args = build_prepare_argument_parser().parse_args(argv)
 
     project_root = Path(args.project_root).expanduser().resolve()
     if args.task_type == "release-handoff":
@@ -3609,6 +4539,25 @@ def main(argv: list[str]) -> int:
             return 1
         selected_direction_abs = str(selected)
 
+    try:
+        host_session_context = deserialize_host_session_context(
+            args.host_session_context_json
+        )
+    except ModelSelectionInputError as exc:
+        print(str(exc), file=__import__("sys").stderr)
+        return 1
+    if not args.host_session_context_json:
+        adapter = default_host_registry().resolve(args.lead_runtime)
+        host_session_context = HostSessionContext(
+            host_id=adapter.descriptor.id,
+            entry_mode="spawn-process",
+            available_functions=frozenset(),
+            interaction_surface="unavailable",
+            current_model=CurrentSessionModelAttestation.unknown(
+                adapter.descriptor.native_provider_id
+            ),
+        )
+
     inputs = PrepareInputs(
         workspace_root=Path(args.workspace_root).resolve(),
         project_root=project_root,
@@ -3621,6 +4570,9 @@ def main(argv: list[str]) -> int:
         evidence_inputs_raw=args.evidence_inputs_raw,
         directive=args.directive,
         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,
         lead_provider=args.lead_provider,
         lead_model=args.lead_model,
         claude_model=args.claude_model,