okstra 0.174.0 → 0.176.0

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -9,7 +9,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 
-from . import cmux
 from .dispatch_state import (
     BACKEND_CLI_WRAPPER,
     BACKEND_CMUX_PANE,
@@ -39,10 +38,46 @@ from .dispatch_state import (
     TEARDOWN_BEFORE_TERMINAL_REASON,
     utc_now as _utc_now,
     validate_dispatch_prompts as _validate_dispatch_prompts,
+    v2_worker_state_key as _v2_worker_state_key,
+    worker_execution_identity as _worker_execution_identity,
     worker_jobs_from_file as _worker_jobs_from_file,
     worker_state as _worker_state,
     worktree_path as _worktree_path,
 )
+from .assignment_resolver import (
+    AssignmentEnvironment,
+    AssignmentResolutionError,
+    RoleInstance,
+    resolve_model_assignment,
+)
+from .application.open_worker import open_worker
+from .domain.host import HostSessionContext
+from .domain.provider import HostModelBinding, ServedModelAttestation
+from .domain.worker_exec import SERVED_MODEL_MISMATCH_EXIT_CODE
+from .domain.worker_runtime import (
+    SURFACE_CMUX_PANE,
+    EnvironmentBlocked,
+    ProgressEvent,
+    RuntimeHandle,
+    SurfaceUnavailable,
+    WorkerSpawnRequest,
+)
+from .ports.worker_runtime import WorkerRuntimePort
+from .execution_identity import Attempt, Invocation, RoleExecution, model_spec_digest
+from .execution_manifest import (
+    finish_attempt_mutation,
+    read_execution_manifest,
+    record_invocation_attempt,
+)
+from .execution_mutation_audit import (
+    ExecutionMutationAudit,
+    MutationAuditResult,
+    MutationSnapshot,
+    assert_compatible_batch,
+)
+from .convergence_store import write_json_atomic
+from .assignment_environment import load_assignment_context
+from .model_pool import ModelPool
 from .error_log_write import append_observed
 from .lead_events import LeadEvent, append_lead_event
 from .initial_prompt_materialization import (
@@ -52,6 +87,7 @@ from .initial_prompt_materialization import (
     PromptDeliveryMode,
     materialize_initial_prompts,
 )
+from .agent_invocation import AgentInvocationError, materialize_retry_invocation
 from .path_hints import hydrate_active_run_context
 from .schema_excerpt import bundle_excerpt_path, excerpt_version_skew
 from .seeding import installed_version
@@ -72,6 +108,15 @@ from .worker_prompt_headers import (
 )
 from .worker_artifact_paths import audit_sidecar_rel
 from .wrapper_status import read_wrapper_status, status_path_for_prompt
+from .worker_request import verifier_extra_dirs
+from .write_policy import (
+    WriteEnforcement,
+    WritePolicy,
+    build_invocation_write_contract,
+    planned_paths_from_run_manifest,
+    write_enforcement_from_payload,
+    write_policy_from_payload,
+)
 
 
 MAX_WORKER_ATTEMPTS = 2
@@ -84,6 +129,102 @@ _WRAPPER_TIMEOUT_EXIT_CODE = 124
 _WRAPPER_LOG_TAIL_BYTES = 800
 
 
+@dataclass(frozen=True)
+class RevalidatedBinding:
+    role_execution_ref: str
+    binding: HostModelBinding
+    model_spec_digest: str
+
+
+def revalidate_role_execution(
+    role_execution: RoleExecution,
+    pool: ModelPool,
+    host: AssignmentEnvironment,
+) -> RevalidatedBinding:
+    """Recompute one selected model binding without inspecting unrelated rows."""
+    if (
+        role_execution.model_ref is None
+        or role_execution.binding is None
+        or role_execution.model_spec_digest is None
+    ):
+        raise DispatchError("model binding changed: role execution is unbound")
+    try:
+        assignment = resolve_model_assignment(
+            instance=RoleInstance(
+                role_execution.role,
+                role_execution.role,
+                role_execution.ordinal,
+            ),
+            model_ref=role_execution.model_ref,
+            pool=pool,
+            host=HostSessionContext(
+                host_id=host.host_descriptor.id,
+                entry_mode="spawn-process",
+                available_functions=frozenset(),
+                interaction_surface="role-execution-dispatch",
+            ),
+            environment=host,
+        )
+        binding = assignment.binding
+        if binding is None:
+            raise AssignmentResolutionError("selected model has no worker binding")
+        digest = model_spec_digest(pool.resolve(role_execution.model_ref), binding)
+    except (ValueError, RuntimeError) as exc:
+        raise DispatchError(f"model binding changed: {exc}") from exc
+    identity_matches = (
+        assignment.provider_id == role_execution.provider
+        and assignment.model_id == role_execution.model_id
+        and binding == role_execution.binding
+        and digest == role_execution.model_spec_digest
+    )
+    if not identity_matches:
+        raise DispatchError("model binding changed for selected role execution")
+    return RevalidatedBinding(role_execution.role_execution_ref, binding, digest)
+
+
+def dispatch_revalidated_role_execution(
+    role_execution: RoleExecution,
+    pool: ModelPool,
+    host: AssignmentEnvironment,
+    dispatch,
+):
+    """Run a dispatch callback only after the pure binding gate succeeds."""
+    binding = revalidate_role_execution(role_execution, pool, host)
+    return dispatch(binding)
+
+
+def verify_served_model(
+    role_execution: RoleExecution,
+    attestation: ServedModelAttestation,
+    *,
+    pool: ModelPool,
+) -> ServedModelAttestation:
+    """Reject observed substitution while preserving unobservable attempts."""
+    if attestation.level == "unknown":
+        return attestation
+    if role_execution.model_ref is None or not attestation.normalized_model_ref:
+        raise DispatchError("served model differs from selected model")
+    try:
+        selected = pool.resolve(role_execution.model_ref)
+        observed = pool.resolve(attestation.normalized_model_ref)
+    except ValueError as exc:
+        raise DispatchError("served model differs from selected model") from exc
+    expected_level = "channel" if observed.version_kind == "channel" else "exact"
+    if attestation.level != expected_level:
+        raise DispatchError("served model attestation level is inconsistent")
+    if selected.version_kind == "pinned":
+        if str(selected.model_ref) != str(observed.model_ref):
+            raise DispatchError("served model differs from selected model")
+        return attestation
+    if (
+        selected.provider_id != observed.provider_id
+        or not selected.channel_family
+        or selected.channel_family != observed.channel_family
+    ):
+        raise DispatchError("served model channel family differs")
+    return attestation
+
+
 @dataclass(frozen=True)
 class WorkerHandle:
     job: WorkerJob
@@ -92,6 +233,12 @@ class WorkerHandle:
     status_sidecar_path: Path | None
     degraded_from: str
     running_process: subprocess.Popen[str] | None = None
+    mutation_snapshot: MutationSnapshot | None = None
+    mutation_policies: tuple[WritePolicy, ...] = ()
+    mutation_retry_allowed: bool = True
+    write_policy_digest: str = ""
+    write_enforcement: WriteEnforcement | None = None
+    runtime_handle: RuntimeHandle | None = None
 
 
 @dataclass(frozen=True)
@@ -115,6 +262,7 @@ class DispatchPlan:
     manifest: Mapping[str, Any]
     jobs: tuple[WorkerJob, ...]
     default_backend: str
+    runtime_chain: tuple[WorkerRuntimePort, ...] = ()
 
     def to_payload(self, dry_run: bool) -> dict[str, Any]:
         payload = {
@@ -221,8 +369,10 @@ def build_dispatch_plan(
 
 
 def dispatch_plan(plan: DispatchPlan, *, wait: bool = True) -> int:
+    plan = _ensure_runtime_chain(plan)
     _validate_report_writer_isolation(plan.jobs)
     _validate_implementation_phase_order(plan.jobs)
+    _revalidate_plan_role_executions(plan)
     if wait:
         pane_backends = sorted(
             {
@@ -253,14 +403,46 @@ def dispatch_cli_wrapper_plan(plan: DispatchPlan) -> int:
     """Start one dependency-free CLI batch before collecting any worker."""
     if any(job.backend != BACKEND_CLI_WRAPPER for job in plan.jobs):
         raise DispatchError("concurrent CLI dispatch requires cli-wrapper jobs only")
+    plan = _ensure_runtime_chain(plan)
     _validate_report_writer_isolation(plan.jobs)
     _validate_implementation_phase_order(plan.jobs)
+    _revalidate_plan_role_executions(plan)
     _record_dispatch_facts(plan.team_state_path, _dispatch_mode(plan.jobs))
     final_codes = _dispatch_cli_wrapper_batch(plan, plan.jobs)
     return next((final_codes[job.worker_id] for job in plan.jobs
                  if final_codes.get(job.worker_id, 0) != 0), 0)
 
 
+def _revalidate_job_role_execution(plan: DispatchPlan, job: WorkerJob) -> None:
+    manifest = read_execution_manifest(plan.manifest_path)
+    executions = {
+        row.role_execution_ref: row for row in manifest.role_executions
+    }
+    context = load_assignment_context(
+        host_runtime=_require_string(plan.manifest, "leadRuntime"),
+        terminal_backend=_require_string(plan.manifest, "terminalBackend"),
+        execution_provider_ids=(job.provider,),
+    )
+    role_execution = executions.get(job.role_execution_ref)
+    if (
+        role_execution is None
+        or role_execution.participant_ref != job.participant_ref
+        or role_execution.execution_label != job.execution_label
+    ):
+        raise DispatchError("worker job role execution does not match run manifest")
+    revalidate_role_execution(
+        role_execution,
+        context.pool,
+        context.environment,
+    )
+
+
+def _revalidate_plan_role_executions(plan: DispatchPlan) -> None:
+    for job in plan.jobs:
+        if job.has_execution_identity:
+            _revalidate_job_role_execution(plan, job)
+
+
 def _validate_report_writer_isolation(jobs: Sequence[WorkerJob]) -> None:
     if (
         any(job.worker_id == REPORT_WRITER_WORKER_ID for job in jobs)
@@ -328,15 +510,60 @@ def _dispatch_cli_wrapper_batch(
     """Run one concurrent batch through all retries before the next dependency."""
     pending = [(job, 1) for job in jobs]
     final_codes: dict[str, int] = {}
+    baseline_snapshot: MutationSnapshot | None = None
     while pending:
         active: list[tuple[WorkerHandle, int]] = []
+        draft_contracts = tuple(
+            _canonical_write_contract(plan, job) if job.has_execution_identity else None
+            for job, _attempt in pending
+        )
+        draft_policies = tuple(
+            contract[0] for contract in draft_contracts if contract is not None
+        )
+        if draft_policies:
+            assert_compatible_batch(draft_policies)
+        prepared = [
+            (_prepare_job_attempt(plan, job, attempt), attempt)
+            for job, attempt in pending
+        ]
+        contracts = tuple(
+            _persisted_write_contract(plan, job) for job, _ in prepared
+        )
+        policies = tuple(
+            contract[0] for contract in contracts if contract is not None
+        )
+        needs_batch = any(
+            contract is not None and contract[1].mutation_audit == "batch"
+            for contract in contracts
+        )
+        if needs_batch and baseline_snapshot is None:
+            baseline_snapshot = _mutation_snapshot(
+                plan, policies, tuple(job for job, _ in prepared)
+            )
+        snapshot = baseline_snapshot if needs_batch else None
         starting_job: WorkerJob | None = None
         starting_attempt = 1
         try:
-            for job, attempt in pending:
+            for (job, attempt), contract in zip(prepared, contracts, strict=True):
                 starting_job = job
                 starting_attempt = attempt
-                active.append((_spawn_cli_job_nonblocking(plan, job, attempt), attempt))
+                handle = _spawn_cli_job_nonblocking(plan, job, attempt)
+                handle = replace(
+                    handle,
+                    mutation_snapshot=snapshot,
+                    mutation_policies=policies,
+                    write_policy_digest=contract[0].digest if contract else "",
+                    write_enforcement=contract[1] if contract else None,
+                )
+                active.append((handle, attempt))
+                _record_dispatch(
+                    plan.team_state_path, handle, attempt, "running", ""
+                )
+                _append_event(
+                    plan,
+                    "worker-dispatched",
+                    _attempt_details(job, attempt, handle),
+                )
         except (OSError, DispatchError) as exc:
             if starting_job is not None:
                 _abort_cli_batch_start(
@@ -344,28 +571,40 @@ def _dispatch_cli_wrapper_batch(
                     active,
                     starting_job,
                     starting_attempt,
-                    pending,
+                    prepared,
+                    snapshot,
+                    policies,
                     exc,
                 )
             raise
+        from .adapters.runtime.assembly import port_for
+
         outcomes: list[tuple[WorkerHandle, int, WorkerOutcome]] = []
         for handle, attempt in active:
-            process = handle.running_process
-            if process is None:
+            runtime = handle.runtime_handle
+            if runtime is None or not runtime.waitable:
                 raise DispatchError("concurrent CLI worker process is missing")
-            returncode = process.wait()
+            port = port_for(plan.runtime_chain, runtime.surface)
+            returncode = port.wait(runtime)
             completed = subprocess.CompletedProcess(handle.job.command, returncode)
-            settled = replace(handle, completed_process=completed, running_process=None)
+            settled = replace(handle, completed_process=completed)
             outcomes.append((settled, attempt, _outcome_from_completed(settled)))
 
         next_round: list[tuple[WorkerJob, int]] = []
         for handle, attempt, outcome in outcomes:
             job = handle.job
-            _finish_attempt(plan, job, attempt, outcome)
-            if _worker_terminal_status(plan.team_state_path, job.worker_id) == "completed":
+            retry_allowed = _finish_attempt(
+                plan,
+                job,
+                attempt,
+                outcome,
+                snapshot=handle.mutation_snapshot,
+                policies=handle.mutation_policies,
+            )
+            if _job_terminal_status(plan, job, attempt) == "completed":
                 final_codes[job.worker_id] = 0
                 continue
-            if _should_retry(outcome, attempt):
+            if _should_retry(outcome, attempt) and retry_allowed:
                 _append_event(
                     plan,
                     "worker-retry-scheduled",
@@ -384,26 +623,27 @@ def _abort_cli_batch_start(
     failed_job: WorkerJob,
     failed_attempt: int,
     pending: Sequence[tuple[WorkerJob, int]],
+    snapshot: MutationSnapshot | None,
+    policies: Sequence[WritePolicy],
     error: Exception,
 ) -> None:
+    from .adapters.runtime.assembly import port_for
+
     reason = f"concurrent CLI batch launch failed: {error}"
     for handle, _attempt in active:
-        process = handle.running_process
-        if process is not None and process.poll() is None:
-            process.terminate()
+        runtime = handle.runtime_handle
+        if runtime is None:
+            continue
+        port_for(plan.runtime_chain, runtime.surface).terminate(runtime)
     for handle, attempt in active:
-        process = handle.running_process
-        if process is not None:
-            process.wait()
-        _transition_worker_status(
-            plan.team_state_path, handle.job.worker_id, "error", reason
-        )
+        runtime = handle.runtime_handle
+        if runtime is not None:
+            port_for(plan.runtime_chain, runtime.surface).wait(runtime)
+        _transition_job_status(plan, handle.job, "error", reason)
         _update_dispatch_status(
             plan.team_state_path, handle.job, attempt, "error", reason
         )
-    _transition_worker_status(
-        plan.team_state_path, failed_job.worker_id, "error", reason
-    )
+    _transition_job_status(plan, failed_job, "error", reason)
     if not _update_dispatch_status(
         plan.team_state_path,
         failed_job,
@@ -411,12 +651,19 @@ def _abort_cli_batch_start(
         "error",
         reason,
     ):
+        failed_contract = _persisted_write_contract(plan, failed_job)
         failed_handle = WorkerHandle(
             failed_job,
             "",
             None,
             status_path_for_prompt(failed_job.prompt_path),
             "",
+            mutation_snapshot=snapshot,
+            mutation_policies=tuple(policies),
+            write_policy_digest=(
+                failed_contract[0].digest if failed_contract else ""
+            ),
+            write_enforcement=(failed_contract[1] if failed_contract else None),
         )
         _record_dispatch(
             plan.team_state_path,
@@ -432,18 +679,21 @@ def _abort_cli_batch_start(
     for job, attempt in pending:
         if (job.worker_id, attempt) in closed:
             continue
-        _transition_worker_status(
-            plan.team_state_path, job.worker_id, "error", reason
-        )
+        _transition_job_status(plan, job, "error", reason)
         if not _update_dispatch_status(
             plan.team_state_path, job, attempt, "error", reason
         ):
+            contract = _persisted_write_contract(plan, job)
             handle = WorkerHandle(
                 job,
                 "",
                 None,
                 status_path_for_prompt(job.prompt_path),
                 "",
+                mutation_snapshot=snapshot,
+                mutation_policies=tuple(policies),
+                write_policy_digest=contract[0].digest if contract else "",
+                write_enforcement=contract[1] if contract else None,
             )
             _record_dispatch(
                 plan.team_state_path,
@@ -452,6 +702,20 @@ def _abort_cli_batch_start(
                 "error",
                 reason,
             )
+    for job, attempt in pending:
+        if not job.has_execution_identity:
+            continue
+        outcome = WorkerOutcome(
+            returncode=1,
+            missing_completion_paths=_missing_completion_paths(job),
+            pane_id="",
+            status_sidecar_path=status_path_for_prompt(job.prompt_path),
+            timeout=False,
+            terminal_stage="launch-failed",
+            degraded_from="",
+        )
+        mutation = _audit_attempt(job, outcome, snapshot, policies)
+        _finish_manifest_attempt(plan, job, attempt, mutation, None)
 
 
 def await_dispatches(
@@ -497,6 +761,15 @@ def _jobs_from_roster(
         options,
         team_state=team_state,
     )
+    if selected == ["translator"]:
+        return [_translator_job_from_reservation(
+            project_root,
+            workspace_root,
+            manifest,
+            team_state,
+            active_context,
+            options,
+        )]
     _mark_roster_skips(project_root, manifest, team_state, selected, requested_workers, options)
     worker_facts, prompt_paths = _materialize_roster_prompts(
         project_root,
@@ -533,6 +806,18 @@ def _select_workers(
     recommended = _string_list(manifest.get("recommendedWorkers"))
     if not recommended:
         raise DispatchError("run manifest has no recommendedWorkers entries")
+    if tuple(requested_workers) == ("translator",):
+        provider = _canonical_translator_provider(manifest)
+        if provider is None:
+            raise DispatchError(
+                "translator dispatch requires a canonical translator role execution"
+            )
+        if provider not in options.supported_worker_wrappers:
+            raise DispatchError(
+                f"unsupported {options.unsupported_worker_label} translator provider: "
+                f"{provider}"
+            )
+        return ["translator"]
     if options.cli_wrapper_assignments_only:
         return _select_cli_wrapper_assignments(
             recommended,
@@ -564,6 +849,178 @@ def _select_workers(
     return selected
 
 
+def _canonical_translator_provider(manifest: Mapping[str, Any]) -> str | None:
+    execution = _canonical_translator_execution(manifest)
+    return _string_value(execution.get("provider")) if execution else None
+
+
+def _canonical_translator_execution(
+    manifest: Mapping[str, Any],
+) -> Mapping[str, Any] | None:
+    assignments = manifest.get("invocationAssignments")
+    assignment = (
+        assignments.get("translator") if isinstance(assignments, Mapping) else None
+    )
+    if not isinstance(assignment, Mapping):
+        return None
+    provider = _string_value(assignment.get("provider"))
+    model_execution = _string_value(assignment.get("modelExecutionValue"))
+    runner = _string_value(assignment.get("runner"))
+    if not provider or not model_execution or runner != BACKEND_CLI_WRAPPER:
+        return None
+    role_executions = manifest.get("roleExecutions")
+    matches = [
+        row
+        for row in role_executions
+        if isinstance(row, Mapping)
+        and row.get("role") == "translator"
+        and row.get("provider") == provider
+        and isinstance(row.get("binding"), Mapping)
+        and row["binding"].get("runner") == runner
+        and row["binding"].get("resolvedExecutionValue") == model_execution
+    ] if isinstance(role_executions, list) else []
+    return matches[0] if len(matches) == 1 else None
+
+
+_TRANSLATOR_RESERVATION_KEYS = {
+    "schemaVersion", "executionIdentityVersion", "invocationId",
+    "assignmentRef", "audience", "dispatchKind", "promptPath",
+    "metadataPath", "invocationRef", "participantRef",
+    "roleExecutionRef", "dutyId", "attempt",
+}
+
+
+def _translator_job_from_reservation(
+    project_root: Path,
+    workspace_root: Path,
+    manifest: Mapping[str, Any],
+    team_state: Mapping[str, Any],
+    active_context: Mapping[str, Any],
+    options: _BuildOptions,
+) -> WorkerJob:
+    execution = _canonical_translator_execution(manifest)
+    if execution is None:
+        raise DispatchError(
+            "translator dispatch requires a canonical translator role execution"
+        )
+    contract = manifest.get("agentContract")
+    if not isinstance(contract, Mapping):
+        raise DispatchError("translator dispatch requires an agent contract")
+    reservation_root = _resolve_required_path(
+        project_root, contract, "invocationReservationRootPath"
+    )
+    dispatched_ids = {
+        str(row.get("dispatchId") or "")
+        for collection in (
+            team_state.get("workerDispatches") or [],
+            team_state.get("agentDispatches") or [],
+        )
+        for row in collection
+        if isinstance(row, Mapping)
+    }
+    candidates: list[Mapping[str, Any]] = []
+    for path in sorted(reservation_root.glob("*.json")):
+        reservation = _load_json_object(path, "agent invocation reservation")
+        if (
+            set(reservation) == _TRANSLATOR_RESERVATION_KEYS
+            and reservation.get("schemaVersion") == "2.0"
+            and reservation.get("executionIdentityVersion") == 2
+            and reservation.get("assignmentRef") == "translator"
+            and reservation.get("audience") == "translator"
+            and reservation.get("dispatchKind") == "translator"
+            and reservation.get("dutyId") == "translator"
+            and reservation.get("participantRef") == execution.get("participantRef")
+            and reservation.get("roleExecutionRef") == execution.get("roleExecutionRef")
+            and _build_dispatch_id(
+                str(reservation.get("invocationId") or ""),
+                int(reservation.get("attempt") or 0),
+            ) not in dispatched_ids
+        ):
+            candidates.append(reservation)
+    if len(candidates) != 1:
+        raise DispatchError(
+            "translator dispatch requires exactly one canonical invocation reservation"
+        )
+    reservation = candidates[0]
+    prompt_path = _resolve_project_path(
+        project_root, _require_string(reservation, "promptPath")
+    )
+    metadata_path = _resolve_project_path(
+        project_root, _require_string(reservation, "metadataPath")
+    )
+    expected_metadata = prompt_path.with_name(prompt_path.name + ".meta.json")
+    if metadata_path != expected_metadata:
+        raise DispatchError("translator invocation metadata path is not prompt-adjacent")
+    metadata = _load_json_object(metadata_path, "agent invocation metadata")
+    invocation = _invocation_job_fields(metadata, prompt_path, manifest)
+    expected = {
+        "invocationId": invocation["invocation_id"],
+        "invocationRef": invocation["invocation_ref"],
+        "participantRef": invocation["participant_ref"],
+        "roleExecutionRef": invocation["role_execution_ref"],
+        "dutyId": invocation["duty_id"],
+        "attempt": invocation["attempt"],
+    }
+    if any(reservation.get(key) != value for key, value in expected.items()):
+        raise DispatchError("translator reservation and invocation metadata differ")
+    if (
+        invocation["audience"] != "translator"
+        or invocation["assignment_ref"] != "translator"
+        or metadata.get("dispatchKind") != "translator"
+    ):
+        raise DispatchError("translator invocation identity is invalid")
+    result_path, worker_result_path = _translator_prompt_outputs(
+        project_root, prompt_path
+    )
+    if result_path == worker_result_path:
+        raise DispatchError(
+            "translator result and standard worker result paths must differ"
+        )
+    provider = _require_string(execution, "provider")
+    binding = execution.get("binding")
+    if not isinstance(binding, Mapping):
+        raise DispatchError("translator role execution has no binding")
+    return WorkerJob(
+        worker_id="translator",
+        provider=provider,
+        backend=options.default_backend,
+        project_root=project_root,
+        model_execution_value=_require_string(binding, "resolvedExecutionValue"),
+        wrapper_path=_resolve_wrapper(provider, workspace_root, options),
+        prompt_path=prompt_path,
+        result_path=result_path,
+        worker_result_path=worker_result_path,
+        completion_paths=(result_path, worker_result_path),
+        worktree_path=_worktree_path(manifest, active_context),
+        role="translator",
+        idle_timeout_seconds=options.idle_timeout_seconds,
+        dispatch_kind="translator",
+        **invocation,
+    )
+
+
+def _translator_prompt_outputs(
+    project_root: Path, prompt_path: Path,
+) -> tuple[Path, Path]:
+    try:
+        lines = prompt_path.read_text(encoding="utf-8").splitlines()
+    except OSError as exc:
+        raise DispatchError(f"cannot read translator prompt: {exc}") from exc
+    values: list[str] = []
+    for header in ("Result Path", "Worker Result Path"):
+        prefix = f"**{header}:** "
+        matches = [line[len(prefix):].strip() for line in lines if line.startswith(prefix)]
+        if len(matches) != 1 or not matches[0]:
+            raise DispatchError(
+                f"translator prompt requires exactly one non-empty {prefix.strip()} header"
+            )
+        values.append(matches[0])
+    return (
+        _resolve_project_path(project_root, values[0]),
+        _resolve_project_path(project_root, values[1]),
+    )
+
+
 def _select_cli_wrapper_assignments(
     recommended: Sequence[str],
     requested_workers: Sequence[str],
@@ -642,7 +1099,7 @@ def _job_from_roster_worker(
 ) -> WorkerJob:
     result_path = _resolve_project_path(project_root, fact.result_path)
     metadata = _agent_metadata(prompt_path)
-    invocation = _invocation_job_fields(metadata, prompt_path)
+    invocation = _invocation_job_fields(metadata, prompt_path, manifest)
     return WorkerJob(
         worker_id=fact.worker_id,
         provider=fact.provider,
@@ -677,6 +1134,7 @@ def _agent_metadata(prompt_path: Path) -> Mapping[str, Any] | None:
 def _invocation_job_fields(
     metadata: Mapping[str, Any] | None,
     prompt_path: Path,
+    manifest: Mapping[str, Any],
 ) -> dict[str, Any]:
     if metadata is None:
         return {}
@@ -687,7 +1145,7 @@ def _invocation_job_fields(
     host_model_value = assignment.get("hostModelValue")
     if host_model_value is not None and not isinstance(host_model_value, str):
         raise DispatchError("agent invocation hostModelValue is invalid")
-    return {
+    fields = {
         "invocation_id": _require_string(metadata, "invocationId"),
         "audience": _require_string(metadata, "audience"),
         "assignment_ref": _require_string(metadata, "assignmentRef"),
@@ -702,6 +1160,37 @@ def _invocation_job_fields(
         "host_model_value": host_model_value,
         "enforcement_mode": "core-pre-dispatch",
     }
+    schema = metadata.get("schemaVersion")
+    identity_version = metadata.get("executionIdentityVersion")
+    if schema == 1 and identity_version is None:
+        return fields
+    if schema != "2.0" or identity_version != 2:
+        raise DispatchError("agent invocation metadata mixes v1 and v2 identity")
+    participant_ref = _require_string(metadata, "participantRef")
+    role_execution_ref = _require_string(metadata, "roleExecutionRef")
+    role_executions = manifest.get("roleExecutions")
+    execution = next((
+        row for row in role_executions
+        if isinstance(row, Mapping)
+        and row.get("roleExecutionRef") == role_execution_ref
+    ), None) if isinstance(role_executions, list) else None
+    if execution is None or execution.get("participantRef") != participant_ref:
+        raise DispatchError("agent invocation role execution does not match run manifest")
+    execution_label = _require_string(metadata, "executionLabel")
+    if execution.get("executionLabel") != execution_label:
+        raise DispatchError("agent invocation execution label does not match run manifest")
+    attempt = metadata.get("attempt")
+    if not isinstance(attempt, int) or isinstance(attempt, bool) or attempt < 1:
+        raise DispatchError("agent invocation v2 attempt must be positive")
+    fields.update({
+        "participant_ref": participant_ref,
+        "role_execution_ref": role_execution_ref,
+        "execution_label": execution_label,
+        "duty_id": _require_string(metadata, "dutyId"),
+        "invocation_ref": _require_string(metadata, "invocationRef"),
+        "attempt": attempt,
+    })
+    return fields
 
 
 def _materialize_roster_prompts(
@@ -775,40 +1264,264 @@ def _jobs_from_file(
 
 
 def _spawn_job(plan: DispatchPlan, job: WorkerJob, attempt: int) -> WorkerHandle:
-    _transition_worker_status(
-        plan.team_state_path, job.worker_id, "in-progress", "",
-        model_execution_value=job.model_execution_value,
+    job = _prepare_job_attempt(plan, job, attempt)
+    contract = _persisted_write_contract(plan, job)
+    policies = (contract[0],) if contract else ()
+    snapshot = None
+    if contract is not None and contract[1].mutation_audit == "batch":
+        snapshot_path = _mutation_snapshot_path(job)
+        if snapshot_path.is_file():
+            snapshot = MutationSnapshot.from_payload(
+                _load_json_object(snapshot_path, "mutation audit snapshot")
+            )
+        else:
+            snapshot = _mutation_snapshot(plan, policies, (job,))
+    handle = replace(
+        _start_job(plan, job),
+        mutation_snapshot=snapshot,
+        mutation_policies=policies,
+        write_policy_digest=contract[0].digest if contract else "",
+        write_enforcement=contract[1] if contract else None,
     )
-    handle = _start_job(plan, job)
     _record_dispatch(plan.team_state_path, handle, attempt, "running", "")
     _append_event(plan, "worker-dispatched", _attempt_details(job, attempt, handle))
     if handle.completed_process is not None:
         outcome = _outcome_from_completed(handle)
-        _finish_attempt(plan, job, attempt, outcome)
+        retry_allowed = _finish_attempt(
+            plan,
+            job,
+            attempt,
+            outcome,
+            snapshot=snapshot,
+            policies=policies,
+        )
+        handle = replace(handle, mutation_retry_allowed=retry_allowed)
     return handle
 
 
 def _spawn_cli_job_nonblocking(
     plan: DispatchPlan, job: WorkerJob, attempt: int,
 ) -> WorkerHandle:
-    _transition_worker_status(
-        plan.team_state_path, job.worker_id, "in-progress", "",
+    plan = _ensure_runtime_chain(plan)
+    try:
+        runtime = open_worker(
+            _chain_starting_at(plan.runtime_chain, job.backend),
+            lambda surface: _spawn_request(plan, job, surface),
+        )
+    except EnvironmentBlocked as exc:
+        raise DispatchError(str(exc)) from exc
+    except (SurfaceUnavailable, OSError) as exc:
+        raise DispatchError(str(exc)) from exc
+    return WorkerHandle(
+        job,
+        "",
+        None,
+        status_path_for_prompt(job.prompt_path),
+        "",
+        runtime_handle=runtime,
+    )
+
+
+def _prepare_job_attempt(
+    plan: DispatchPlan, job: WorkerJob, attempt: int
+) -> WorkerJob:
+    if job.has_execution_identity:
+        _revalidate_job_role_execution(plan, job)
+        job = _job_for_attempt(job, attempt)
+        _record_execution_attempt(plan, job)
+    _transition_job_status(
+        plan,
+        job,
+        "in-progress",
+        "",
         model_execution_value=job.model_execution_value,
     )
-    process: subprocess.Popen[str] | None = None
+    return job
+
+
+def _persisted_write_contract(
+    plan: DispatchPlan, job: WorkerJob
+) -> tuple[WritePolicy, WriteEnforcement] | None:
+    if not job.has_execution_identity:
+        return None
+    manifest = read_execution_manifest(plan.manifest_path)
+    invocation = next(
+        (
+            row for row in manifest.invocations
+            if row.invocation_ref == job.invocation_ref
+        ),
+        None,
+    )
+    if invocation is None:
+        raise DispatchError("worker invocation write policy was not persisted")
     try:
-        process = subprocess.Popen(job.command, cwd=plan.project_root, text=True)
-        handle = WorkerHandle(
-            job, "", None, status_path_for_prompt(job.prompt_path), "", process
+        enforcement = write_enforcement_from_payload(
+            invocation.write_enforcement
         )
-        _record_dispatch(plan.team_state_path, handle, attempt, "running", "")
-        _append_event(plan, "worker-dispatched", _attempt_details(job, attempt, handle))
-        return handle
-    except (OSError, DispatchError):
-        if process is not None and process.poll() is None:
-            process.terminate()
-            process.wait()
-        raise
+        policy = replace(
+            write_policy_from_payload(invocation.write_policy),
+            maximum_boundary_precision=enforcement.boundary_precision,
+        )
+    except (TypeError, ValueError) as exc:
+        raise DispatchError(f"persisted worker write policy is invalid: {exc}") from exc
+    if policy.digest != invocation.write_policy_digest:
+        raise DispatchError("persisted worker write policy digest changed")
+    return policy, enforcement
+
+
+def _mutation_snapshot(
+    plan: DispatchPlan,
+    policies: Sequence[WritePolicy],
+    jobs: Sequence[WorkerJob],
+) -> MutationSnapshot:
+    sidecars = tuple(_mutation_snapshot_path(job) for job in jobs)
+    snapshot = ExecutionMutationAudit().snapshot(
+        policies,
+        orchestrator_paths=(
+            plan.manifest_path,
+            plan.team_state_path,
+            Path(f"{plan.team_state_path}.lock"),
+            plan.lead_events_path,
+            plan.lead_events_path.with_name(
+                f".{plan.lead_events_path.name}.lock"
+            ),
+            *sidecars,
+        ),
+    )
+    for path in sidecars:
+        write_json_atomic(path, snapshot.to_payload())
+    return snapshot
+
+
+def _mutation_snapshot_path(job: WorkerJob) -> Path:
+    return job.prompt_path.with_suffix(job.prompt_path.suffix + ".mutation-audit.json")
+
+
+def _record_execution_attempt(plan: DispatchPlan, job: WorkerJob) -> None:
+    task_key = _require_string(plan.manifest, "taskKey")
+    write_policy, write_enforcement = _canonical_write_contract(plan, job)
+    record_invocation_attempt(
+        plan.manifest_path,
+        Invocation(
+            invocation_ref=job.invocation_ref,
+            participant_ref=job.participant_ref,
+            role_execution_ref=job.role_execution_ref,
+            source_invocation_ref=None,
+            recovery_ref=None,
+            duty_id=job.duty_id,
+            dispatch_kind=job.dispatch_kind,
+            round=_dispatch_round(job.dispatch_kind),
+            input_digest=job.prompt_digest,
+            write_policy=write_policy.to_payload(),
+            write_policy_digest=write_policy.digest,
+            write_enforcement=write_enforcement.to_payload(),
+        ),
+        Attempt(
+            invocation_ref=job.invocation_ref,
+            attempt=job.attempt,
+            started_at=_utc_now(),
+            finished_at=None,
+            status="started",
+            result_path=None,
+            error_path=None,
+            change_summary={},
+            evidence_seal_ref=None,
+        ),
+        task_key=task_key,
+    )
+
+
+def _canonical_write_contract(
+    plan: DispatchPlan, job: WorkerJob
+) -> tuple[WritePolicy, WriteEnforcement]:
+    manifest = read_execution_manifest(plan.manifest_path)
+    execution = next(
+        (
+            row for row in manifest.role_executions
+            if row.role_execution_ref == job.role_execution_ref
+        ),
+        None,
+    )
+    if execution is None or execution.binding is None:
+        raise DispatchError("worker write policy has no role execution binding")
+    capability = execution.binding.worker_write_capability
+    if capability is None:
+        raise DispatchError("worker write policy has no runner write capability")
+    artifacts = _worker_artifact_paths(plan, job)
+    worktree = Path(job.worktree_path) if job.worktree_path else None
+    try:
+        return build_invocation_write_contract(
+            role=execution.role,
+            project_root=plan.project_root,
+            worktree=worktree,
+            artifact_paths=artifacts,
+            maximum_precision=capability.max_boundary_precision,
+            planned_paths=(
+                planned_paths_from_run_manifest(plan.project_root, plan.manifest)
+                if execution.role == "implementer"
+                else ()
+            ),
+            auxiliary_roots=verifier_extra_dirs(execution.role),
+            validated_auxiliary_roots=verifier_extra_dirs(execution.role),
+        )
+    except (OSError, ValueError) as exc:
+        raise DispatchError(f"worker write policy is invalid: {exc}") from exc
+
+
+def _worker_artifact_paths(plan: DispatchPlan, job: WorkerJob) -> tuple[Path, ...]:
+    active_context = _load_optional_json(
+        plan.project_root, plan.manifest.get("activeRunContextPath")
+    )
+    paths = {
+        job.result_path,
+        job.worker_result_path,
+        *job.completion_paths,
+        Path(audit_sidecar_rel(str(job.worker_result_path))),
+        status_path_for_prompt(job.prompt_path),
+        job.prompt_path.with_suffix(job.prompt_path.suffix + ".log"),
+    }
+    error_logs = active_context.get("errorLogs")
+    if isinstance(error_logs, Mapping):
+        sidecars = error_logs.get("sidecarsByWorkerId")
+        if isinstance(sidecars, Mapping):
+            value = _string_value(sidecars.get(job.worker_id))
+            if value:
+                paths.add(_resolve_project_path(plan.project_root, value))
+    return tuple(sorted(paths, key=str))
+
+
+
+
+def _job_for_attempt(job: WorkerJob, attempt: int) -> WorkerJob:
+    if attempt == job.attempt:
+        return job
+    try:
+        retry = materialize_retry_invocation(
+            job.prompt_metadata_path,
+            project_root=job.project_root,
+            attempt=attempt,
+        )
+    except AgentInvocationError as exc:
+        raise DispatchError(f"cannot materialize retry invocation: {exc}") from exc
+    if retry.invocation_ref != job.invocation_ref:
+        raise DispatchError("retry invocation reference changed")
+    return replace(
+        job,
+        prompt_path=retry.prompt_path,
+        prompt_metadata_path=retry.metadata_path,
+        invocation_id=retry.invocation_id,
+        attempt=retry.attempt,
+    )
+
+
+def _dispatch_round(dispatch_kind: str) -> int:
+    prefix = "reverify-r"
+    if not dispatch_kind.startswith(prefix):
+        return 1
+    suffix = dispatch_kind[len(prefix):]
+    if not suffix.isdigit() or int(suffix) < 1:
+        raise DispatchError(f"invalid reverify dispatch kind: {dispatch_kind}")
+    return int(suffix)
 
 
 def _dispatch_job_with_retry(plan: DispatchPlan, job: WorkerJob) -> int:
@@ -817,9 +1530,9 @@ def _dispatch_job_with_retry(plan: DispatchPlan, job: WorkerJob) -> int:
         if handle.completed_process is None:
             return await_dispatches(plan, timeout_seconds=None)
         outcome = _outcome_from_completed(handle)
-        if _worker_terminal_status(plan.team_state_path, job.worker_id) == "completed":
+        if _job_terminal_status(plan, job, attempt) == "completed":
             return 0
-        if _should_retry(outcome, attempt):
+        if _should_retry(outcome, attempt) and handle.mutation_retry_allowed:
             _append_event(plan, "worker-retry-scheduled", _retry_details(job, attempt, outcome))
             job = _job_for_next_attempt(job)
             continue
@@ -827,31 +1540,66 @@ def _dispatch_job_with_retry(plan: DispatchPlan, job: WorkerJob) -> int:
     return 1
 
 
+def _ensure_runtime_chain(plan: DispatchPlan) -> DispatchPlan:
+    if plan.runtime_chain:
+        return plan
+    from .adapters.runtime.assembly import runtime_chain as build_chain
+    return replace(plan, runtime_chain=build_chain(plan.default_backend))
+
+
+def _spawn_request(
+    plan: DispatchPlan, job: WorkerJob, surface: str
+) -> WorkerSpawnRequest:
+    targeted = replace(job, backend=surface)
+    title = (
+        targeted.execution_label
+        if targeted.has_execution_identity
+        else f"{targeted.worker_id}-worker"
+    )
+    return WorkerSpawnRequest(
+        command=tuple(targeted.command),
+        cwd=plan.project_root,
+        title=title,
+        owned_surface_ids=_opened_cmux_surfaces(plan.team_state_path),
+    )
+
+
+def _chain_starting_at(
+    chain: tuple[WorkerRuntimePort, ...], surface: str
+) -> tuple[WorkerRuntimePort, ...]:
+    # A retry job is already cli-wrapper; do not walk back up to cmux-pane.
+    for index, port in enumerate(chain):
+        if port.surface == surface:
+            return chain[index:]
+    raise DispatchError(f"unsupported worker backend: {surface}")
+
+
 def _start_job(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
-    if job.backend == BACKEND_CLI_WRAPPER:
-        return _run_cli_wrapper(plan, job, "")
-    if job.backend == BACKEND_CMUX_PANE:
-        return _start_cmux_or_degrade(plan, job)
-    raise DispatchError(f"unsupported worker backend: {job.backend}")
-
-
-def _start_cmux_or_degrade(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
-    workspace = cmux.resolve_lead_workspace()
-    if not workspace:
-        _refuse_when_cmux_is_walled_off()
-        return _run_cli_wrapper(plan, job, BACKEND_CMUX_PANE)
+    plan = _ensure_runtime_chain(plan)
     try:
-        surface_id = cmux.spawn_worker_surface(
-            workspace=workspace,
-            cwd=plan.project_root,
-            command=job.command,
-            title=f"{job.worker_id}-worker",
-            owned_surface_ids=_opened_cmux_surfaces(plan.team_state_path),
+        runtime = open_worker(
+            _chain_starting_at(plan.runtime_chain, job.backend),
+            lambda surface: _spawn_request(plan, job, surface),
         )
-    except (RuntimeError, OSError, subprocess.SubprocessError):
-        return _run_cli_wrapper(plan, job, BACKEND_CMUX_PANE)
+    except EnvironmentBlocked as exc:
+        raise DispatchError(str(exc)) from exc
+    except SurfaceUnavailable as exc:
+        raise DispatchError(str(exc)) from exc
+    degraded_from = job.backend if runtime.surface != job.backend else ""
+    settled = replace(job, backend=runtime.surface) if degraded_from else job
+    completed = None
+    if runtime.waitable:
+        from .adapters.runtime.assembly import port_for
+        returncode = port_for(plan.runtime_chain, runtime.surface).wait(runtime)
+        completed = subprocess.CompletedProcess(list(settled.command), returncode)
+    pane_id = runtime.identifier if runtime.surface == SURFACE_CMUX_PANE else ""
     return WorkerHandle(
-        job, surface_id, None, status_path_for_prompt(job.prompt_path), ""
+        settled,
+        pane_id,
+        completed,
+        status_path_for_prompt(settled.prompt_path),
+        degraded_from,
+        runtime_handle=runtime,
     )
 
 
@@ -877,42 +1625,6 @@ def _opened_cmux_surfaces(team_state_path: Path) -> tuple[str, ...]:
     return tuple(opened)
 
 
-def _refuse_when_cmux_is_walled_off() -> None:
-    """Stop rather than degrade when a sandbox stands between okstra and cmux.
-
-    prepare records `cmux-pane` only after reaching cmux, so losing it by
-    dispatch time means something came between. When the socket is present but
-    connecting is denied, that something is a sandbox around the lead — and the
-    same sandbox hides the worker CLIs' own config, so the fallback this would
-    otherwise take is already dead. Degrading here spends every worker's retry
-    budget on the same wall and leaves the user with three failures and no
-    explanation, which is exactly what it looks like when nothing happens.
-    """
-    reason = cmux.unreachable_reason()
-    if reason not in (cmux.LOST_ENVIRONMENT, cmux.LOST_DENIED):
-        return
-    observed = (
-        "this process has no cmux environment left — a sandbox sanitized it"
-        if reason == cmux.LOST_ENVIRONMENT
-        else "cmux is running but this process may not connect to its socket"
-    )
-    raise DispatchError(
-        f"this run was prepared for cmux panes, but {observed}. The same "
-        "sandbox blocks worker CLIs from their own config, so falling back to "
-        "blocking workers would fail too. Relaunch the lead outside a sandbox "
-        "(codex: `codex -s danger-full-access`)."
-    )
-
-
-def _run_cli_wrapper(plan: DispatchPlan, job: WorkerJob, degraded_from: str) -> WorkerHandle:
-    # Whatever the job was planned as, this is a cli-wrapper dispatch: no pane
-    # took it, so the worker's stdout is read by whoever called the lead. The
-    # record already says so (`_dispatch_record`), and the command must agree.
-    job = replace(job, backend=BACKEND_CLI_WRAPPER)
-    completed = subprocess.run(job.command, cwd=plan.project_root, text=True)
-    return WorkerHandle(job, "", completed, status_path_for_prompt(job.prompt_path), degraded_from)
-
-
 def _outcome_from_completed(handle: WorkerHandle) -> WorkerOutcome:
     completed = handle.completed_process
     if completed is None:
@@ -964,16 +1676,17 @@ def _advance_running_dispatches(plan: DispatchPlan, records: Sequence[Mapping[st
         if status is None or not status.is_terminal:
             continue
         outcome = _outcome_from_status(record, status)
-        if _should_retry(outcome, int(record.get("attempt", 1))):
+        retry_allowed = _finish_record(plan, record, outcome)
+        if (
+            _should_retry(outcome, int(record.get("attempt", 1)))
+            and retry_allowed
+        ):
             _retry_from_record(plan, record, outcome)
-            continue
-        _finish_record(plan, record, outcome)
 
 
 def _retry_from_record(
     plan: DispatchPlan, record: Mapping[str, Any], outcome: WorkerOutcome
 ) -> None:
-    worker_id = _require_string(record, "workerId")
     attempt = int(record.get("attempt", 1))
     job = _job_from_record(plan.project_root, record)
     reason = "required worker artifact was not produced"
@@ -981,7 +1694,7 @@ def _retry_from_record(
     # `team-contract` counts the first attempt's failure as a recorded
     # `cli-failure`; a retry that succeeds settles `completed` and would
     # otherwise leave no trace that anything had to be re-run.
-    details: dict[str, Any] = {"workerId": worker_id, "attempt": attempt}
+    details = _event_execution_identity(job, attempt)
     details["errorLogAppend"] = _record_wrapper_failure(
         plan, job, attempt, outcome, reason
     )
@@ -991,14 +1704,37 @@ def _retry_from_record(
     _spawn_job(plan, _job_for_next_attempt(job), attempt + 1)
 
 
-def _finish_attempt(plan: DispatchPlan, job: WorkerJob, attempt: int, outcome: WorkerOutcome) -> None:
+def _finish_attempt(
+    plan: DispatchPlan,
+    job: WorkerJob,
+    attempt: int,
+    outcome: WorkerOutcome,
+    *,
+    snapshot: MutationSnapshot | None = None,
+    policies: Sequence[WritePolicy] = (),
+) -> bool:
+    mutation = _audit_attempt(job, outcome, snapshot, policies)
+    if mutation is not None and mutation.status in {
+        "contract-failed-unattributed",
+        "mutation-present-unresolved",
+    }:
+        reason = "; ".join(mutation.violations) or mutation.status
+        _transition_job_status(plan, job, "error", reason)
+        _update_dispatch_status(
+            plan.team_state_path, job, attempt, "error", reason
+        )
+        details = _failure_details(job, attempt, outcome, reason)
+        details["mutationAudit"] = mutation.change_summary()
+        _append_event(plan, "worker-failed", details)
+        _finish_manifest_attempt(plan, job, attempt, mutation, None)
+        return False
     settlement = _settle(plan, job, attempt, outcome)
     if settlement.completed:
         result_link = _link_result(plan, job, attempt)
         post_process = _post_process_report_writer_result(plan, job)
         if not post_process["ok"]:
             reason = _require_string(post_process, "reason")
-            _transition_worker_status(plan.team_state_path, job.worker_id, "error", reason)
+            _transition_job_status(plan, job, "error", reason)
             _update_dispatch_status(
                 plan.team_state_path,
                 job,
@@ -1015,10 +1751,9 @@ def _finish_attempt(plan: DispatchPlan, job: WorkerJob, attempt: int, outcome: W
             )
             details["postProcessing"] = post_process["steps"]
             _append_event(plan, "worker-failed", details)
-            return
-        _transition_worker_status(
-            plan.team_state_path, job.worker_id, "completed", ""
-        )
+            _finish_manifest_attempt(plan, job, attempt, mutation, None)
+            return False
+        _transition_job_status(plan, job, "completed", "")
         _update_dispatch_status(
             plan.team_state_path,
             job,
@@ -1031,16 +1766,148 @@ def _finish_attempt(plan: DispatchPlan, job: WorkerJob, attempt: int, outcome: W
         details["resultLink"] = result_link
         if settlement.error_log_append is not None:
             details["errorLogAppend"] = settlement.error_log_append
+        if mutation is not None:
+            details["mutationAudit"] = mutation.change_summary()
         _append_event(plan, "worker-result-collected", details)
-        return
+        _finish_manifest_attempt(
+            plan, job, attempt, mutation, job.worker_result_path
+        )
+        return False
     reason = settlement.reason
     status = "timeout" if outcome.timeout else "error"
-    _transition_worker_status(plan.team_state_path, job.worker_id, status, reason)
+    _transition_job_status(plan, job, status, reason)
     _update_dispatch_status(plan.team_state_path, job, attempt, status, reason)
     details = _failure_details(job, attempt, outcome, reason)
     if settlement.error_log_append is not None:
         details["errorLogAppend"] = settlement.error_log_append
+    if mutation is not None:
+        details["mutationAudit"] = mutation.change_summary()
     _append_event(plan, "worker-failed", details)
+    _finish_manifest_attempt(plan, job, attempt, mutation, None)
+    return mutation.retry_allowed if mutation is not None else True
+
+
+def _audit_attempt(
+    job: WorkerJob,
+    outcome: WorkerOutcome,
+    snapshot: MutationSnapshot | None,
+    policies: Sequence[WritePolicy],
+) -> MutationAuditResult | None:
+    if not job.has_execution_identity or not policies:
+        return None
+    succeeded = outcome.returncode == 0 and not outcome.timeout
+    result_present = not outcome.missing_completion_paths
+    if snapshot is None:
+        status = "ok" if succeeded and result_present else "failed-no-mutation"
+        return MutationAuditResult(
+            status=status,
+            changed_paths=(),
+            source_changed=False,
+            git_changed=False,
+            attribution="call",
+            retry_allowed=status == "failed-no-mutation",
+            violations=(),
+            before_digest="",
+            after_digest="",
+            git_projection={},
+        )
+    return ExecutionMutationAudit().compare(
+        snapshot,
+        policies,
+        out_of_plan_edits=_out_of_plan_edit_paths(job.result_path),
+        attempt_succeeded=succeeded,
+        result_present=result_present,
+    )
+
+
+def _out_of_plan_edit_paths(result_path: Path) -> tuple[str, ...]:
+    if not result_path.is_file() or result_path.suffix != ".json":
+        return ()
+    try:
+        payload = json.loads(result_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return ()
+    implementation = payload.get("implementation") if isinstance(payload, Mapping) else None
+    rows = implementation.get("outOfPlanEdits") if isinstance(implementation, Mapping) else None
+    if not isinstance(rows, list):
+        return ()
+    return tuple(
+        str(row["file"])
+        for row in rows
+        if isinstance(row, Mapping)
+        and isinstance(row.get("file"), str)
+        and row["file"]
+    )
+
+
+def _finish_manifest_attempt(
+    plan: DispatchPlan,
+    job: WorkerJob,
+    attempt: int,
+    mutation: MutationAuditResult | None,
+    result_path: Path | None,
+) -> None:
+    if mutation is None:
+        return
+    manifest = read_execution_manifest(plan.manifest_path)
+    existing = next(
+        (
+            row for row in manifest.attempts
+            if row.invocation_ref == job.invocation_ref
+            and row.attempt == attempt
+        ),
+        None,
+    )
+    expected_result = str(result_path) if result_path is not None else None
+    if existing is not None and existing.finished_at is not None:
+        if (
+            existing.status == mutation.status
+            and existing.result_path == expected_result
+            and dict(existing.change_summary) == mutation.change_summary()
+        ):
+            return
+        raise DispatchError("attempt terminal mutation result drift")
+    finish_attempt_mutation(
+        plan.manifest_path,
+        invocation_ref=job.invocation_ref,
+        attempt=attempt,
+        finished_at=_utc_now(),
+        status=mutation.status,
+        result_path=expected_result,
+        error_path=None,
+        change_summary=mutation.change_summary(),
+        task_key=_require_string(plan.manifest, "taskKey"),
+    )
+    _seal_finished_attempt(plan, job, attempt, mutation)
+
+
+def _seal_finished_attempt(plan, job, attempt, mutation) -> None:
+    from .attempt_evidence import TerminalObservation, finalize_attempt
+
+    events = job.prompt_path.with_name(job.prompt_path.name + ".host-events.jsonl")
+    if not events.is_file() or not job.has_execution_identity:
+        return
+    artifacts = tuple(
+        path for path in (job.result_path, job.worker_result_path) if path
+    )
+    try:
+        finalize_attempt(
+            plan.manifest_path,
+            _build_dispatch_id(job.invocation_ref, attempt),
+            TerminalObservation(
+                status=mutation.status,
+                source_diff_digest=mutation.change_summary().get("beforeDigest", ""),
+                git_projection_digest=mutation.change_summary().get("afterDigest", ""),
+                changed_paths=tuple(mutation.changed_paths),
+                artifact_paths=artifacts,
+                host_event_stream_path=events,
+                project_root=plan.project_root,
+                worktree=Path(job.worktree_path) if job.worktree_path else None,
+            ),
+            task_key=_require_string(plan.manifest, "taskKey"),
+        )
+    except (OSError, ValueError):
+        return
 
 
 def _link_result(
@@ -1080,9 +1947,34 @@ def _link_result(
     return link
 
 
-def _finish_record(plan: DispatchPlan, record: Mapping[str, Any], outcome: WorkerOutcome) -> None:
+def _finish_record(
+    plan: DispatchPlan,
+    record: Mapping[str, Any],
+    outcome: WorkerOutcome,
+) -> bool:
     job = _job_from_record(plan.project_root, record)
-    _finish_attempt(plan, job, int(record.get("attempt", 1)), outcome)
+    snapshot = _snapshot_from_record(record)
+    contract = _persisted_write_contract(plan, job)
+    policies = (contract[0],) if contract is not None else ()
+    return _finish_attempt(
+        plan,
+        job,
+        int(record.get("attempt", 1)),
+        outcome,
+        snapshot=snapshot,
+        policies=policies,
+    )
+
+
+def _snapshot_from_record(record: Mapping[str, Any]) -> MutationSnapshot | None:
+    value = _string_value(record.get("mutationAuditSnapshotPath"))
+    if not value:
+        return None
+    payload = _load_json_object(Path(value), "mutation audit snapshot")
+    try:
+        return MutationSnapshot.from_payload(payload)
+    except (KeyError, TypeError, ValueError) as exc:
+        raise DispatchError("mutation audit snapshot is invalid") from exc
 
 
 @dataclass(frozen=True)
@@ -1120,7 +2012,11 @@ def _settle(
     reason = _failure_reason(outcome)
     completed = False
     note = ""
-    if not outcome.timeout and not outcome.missing_completion_paths:
+    if (
+        outcome.returncode != SERVED_MODEL_MISMATCH_EXIT_CODE
+        and not outcome.timeout
+        and not outcome.missing_completion_paths
+    ):
         audit_failures = _audit_sidecar_failures(job)
         if audit_failures:
             reason = (
@@ -1214,6 +2110,11 @@ def _record_wrapper_failure(
             message=f"attempt {attempt}: {message}",
             stderr_excerpt=_wrapper_log_tail(job),
             context=None,
+            identity=(
+                _job_stored_identity(job, attempt)
+                if job.has_execution_identity
+                else None
+            ),
         )
     except (OSError, ValueError, TypeError, WorkerPromptHeaderError) as exc:
         result["reason"] = f"{type(exc).__name__}: {exc}"
@@ -1222,6 +2123,17 @@ def _record_wrapper_failure(
     return result
 
 
+def _job_stored_identity(job: WorkerJob, attempt: int) -> dict[str, Any]:
+    """Copy the job's stored execution refs. Do not infer them from labels."""
+    return {
+        "participantRef": job.participant_ref,
+        "roleExecutionRef": job.role_execution_ref,
+        "invocationRef": job.invocation_ref,
+        "attempt": job.attempt or attempt,
+        "executionLabel": job.execution_label,
+    }
+
+
 def _error_log_agent(worker_id: str) -> str:
     """The error log's `--agent` enum value for a worker id.
 
@@ -1300,9 +2212,87 @@ def _post_process_report_writer_result(
         return {"ok": False, "reason": str(exc), "steps": []}
 
 
-def _worker_terminal_status(team_state_path: Path, worker_id: str) -> str:
-    team_state = _load_json_object(team_state_path, "team-state")
-    return _string_value(_worker_state(team_state, worker_id).get("status"))
+def _projectionless_translator(plan: DispatchPlan, job: WorkerJob) -> bool:
+    if not (
+        job.has_execution_identity
+        and job.role == "translator"
+        and job.worker_id == "translator"
+        and job.audience == "translator"
+        and job.assignment_ref == "translator"
+        and job.duty_id == "translator"
+        and job.dispatch_kind == "translator"
+    ):
+        return False
+    execution = _canonical_translator_execution(plan.manifest)
+    return bool(
+        execution
+        and execution.get("roleExecutionRef") == job.role_execution_ref
+        and execution.get("participantRef") == job.participant_ref
+        and execution.get("executionLabel") == job.execution_label
+        and execution.get("provider") == job.provider
+    )
+
+
+def _transition_job_status(
+    plan: DispatchPlan,
+    job: WorkerJob,
+    status: str,
+    reason: str,
+    *,
+    model_execution_value: str = "",
+) -> None:
+    if not _projectionless_translator(plan, job):
+        _transition_worker_status(
+            plan.team_state_path,
+            job.worker_id,
+            status,
+            reason,
+            model_execution_value=model_execution_value,
+        )
+        return
+    team_state = _load_json_object(plan.team_state_path, "team-state")
+    workers = team_state.get("workers")
+    if not isinstance(workers, list):
+        raise DispatchError("team-state workers must be an array")
+    if not any(
+        isinstance(row, Mapping) and row.get("workerId") == job.worker_id
+        for row in workers
+    ):
+        return
+    _transition_worker_status(
+        plan.team_state_path,
+        job.worker_id,
+        status,
+        reason,
+        model_execution_value=model_execution_value,
+    )
+
+
+def _job_terminal_status(
+    plan: DispatchPlan, job: WorkerJob, attempt: int,
+) -> str:
+    team_state = _load_json_object(plan.team_state_path, "team-state")
+    workers = team_state.get("workers")
+    if not isinstance(workers, list):
+        raise DispatchError("team-state workers must be an array")
+    matches = [
+        row for row in workers
+        if isinstance(row, Mapping) and row.get("workerId") == job.worker_id
+    ]
+    if len(matches) == 1:
+        return _string_value(matches[0].get("status"))
+    if matches or not _projectionless_translator(plan, job):
+        raise DispatchError(f"team-state has no unique workerId={job.worker_id}")
+    dispatches = team_state.get("workerDispatches")
+    records = [
+        row for row in dispatches
+        if isinstance(row, Mapping)
+        and row.get("promptPath") == str(job.prompt_path)
+        and row.get("attempt") == attempt
+    ] if isinstance(dispatches, list) else []
+    if len(records) != 1:
+        raise DispatchError("translator dispatch has no unique status record")
+    return _string_value(records[0].get("status"))
 
 
 def _record_dispatch(
@@ -1317,15 +2307,31 @@ def _record_dispatch(
             handle.pane_id,
             handle.degraded_from,
             reason,
+            mutation_snapshot_path=(
+                _mutation_snapshot_path(handle.job)
+                if handle.mutation_snapshot is not None
+                else None
+            ),
+            write_policy_digest=handle.write_policy_digest,
+            write_enforcement=handle.write_enforcement,
         ),
     )
 
 
 def _dispatch_record(
-    job: WorkerJob, attempt: int, status: str, pane_id: str, degraded_from: str, reason: str = ""
+    job: WorkerJob,
+    attempt: int,
+    status: str,
+    pane_id: str,
+    degraded_from: str,
+    reason: str = "",
+    *,
+    mutation_snapshot_path: Path | None = None,
+    write_policy_digest: str = "",
+    write_enforcement: WriteEnforcement | None = None,
 ) -> dict[str, Any]:
+    has_execution_identity = job.has_execution_identity
     record = {
-        "workerId": job.worker_id,
         "role": job.role,
         "kind": job.dispatch_kind,
         "attempt": attempt,
@@ -1363,6 +2369,27 @@ def _dispatch_record(
             "hostModelValue": job.host_model_value,
             "enforcementMode": job.enforcement_mode,
         })
+    if has_execution_identity:
+        record.update({
+            "schemaVersion": "2.0",
+            "executionIdentityVersion": 2,
+            "participantRef": job.participant_ref,
+            "roleExecutionRef": job.role_execution_ref,
+            "executionLabel": job.execution_label,
+            "dutyId": job.duty_id,
+            "invocationRef": job.invocation_ref,
+            "writePolicyDigest": write_policy_digest,
+            "writeEnforcement": (
+                write_enforcement.to_payload()
+                if write_enforcement is not None
+                else None
+            ),
+            "mutationAuditSnapshotPath": (
+                str(mutation_snapshot_path) if mutation_snapshot_path else ""
+            ),
+        })
+    else:
+        record["workerId"] = job.worker_id
     return record
 
 
@@ -1487,31 +2514,33 @@ _SIDEBAR_LEVELS = {
 
 
 def _relay_to_sidebar(plan: DispatchPlan, event_type: str, details: Mapping[str, Any]) -> None:
-    """Mirror a dispatch event onto the cmux sidebar.
+    """Mirror a dispatch event onto the lead surface.
 
-    A long run is mostly silence, and the sidebar is the one surface still
+    A long run is mostly silence, and the lead surface is the one still
     visible after the user scrolls away or switches workspaces. A failed worker
     additionally raises a notification, because that is the event whose cost
-    grows the longer it goes unnoticed.
+    grows the longer it goes unnoticed. The lead port is `runtime_chain[0]`,
+    so a worker that degraded to the wrapper still lands on a cmux run's
+    sidebar. A cli-wrapper lead is a no-op.
     """
-    # The plan's backend, not the manifest field it was resolved from: a job
-    # that degraded to the blocking wrapper is still part of a cmux run, and
-    # that degradation is exactly what the sidebar should keep showing.
-    if plan.default_backend != BACKEND_CMUX_PANE:
-        return
-    workspace = cmux.resolve_lead_workspace()
-    worker_id = str(details.get("workerId", "") or "worker")
-    cmux.sidebar_log(
-        workspace,
-        f"{worker_id}: {event_type.removeprefix('worker-')}",
-        level=_SIDEBAR_LEVELS.get(event_type, "info"),
+    plan = _ensure_runtime_chain(plan)
+    lead = plan.runtime_chain[0]
+    worker_id = str(
+        details.get("executionLabel") or details.get("workerId") or "worker"
     )
+    notify_title = None
+    notify_body = None
     if event_type == "worker-failed":
-        cmux.sidebar_notify(
-            workspace,
-            title=f"okstra — {_require_string(plan.manifest, 'taskType')}",
-            body=f"{worker_id} failed: {details.get('reason', 'no reason recorded')}",
+        notify_title = f"okstra — {_require_string(plan.manifest, 'taskType')}"
+        notify_body = f"{worker_id} failed: {details.get('reason', 'no reason recorded')}"
+    lead.notify(
+        ProgressEvent(
+            message=f"{worker_id}: {event_type.removeprefix('worker-')}",
+            level=_SIDEBAR_LEVELS.get(event_type, "info"),
+            notify_title=notify_title,
+            notify_body=notify_body,
         )
+    )
 
 
 def _append_event(plan: DispatchPlan, event_type: str, details: Mapping[str, Any]) -> None:
@@ -1531,13 +2560,16 @@ def _append_event(plan: DispatchPlan, event_type: str, details: Mapping[str, Any
 
 
 def _attempt_details(job: WorkerJob, attempt: int, handle: WorkerHandle) -> dict[str, Any]:
-    return {**_event_details(job, handle), "attempt": attempt, "maxAttempts": MAX_WORKER_ATTEMPTS}
+    return {
+        **_event_details(job, handle),
+        **_event_execution_identity(job, attempt),
+        "maxAttempts": MAX_WORKER_ATTEMPTS,
+    }
 
 
 def _event_details(job: WorkerJob, handle: WorkerHandle) -> dict[str, Any]:
-    return {
+    details = {
         "dispatchMode": BACKEND_CLI_WRAPPER if handle.degraded_from else job.backend,
-        "workerId": job.worker_id,
         "promptPath": str(job.prompt_path),
         "resultPath": str(job.result_path),
         "workerResultPath": str(job.worker_result_path),
@@ -1546,12 +2578,25 @@ def _event_details(job: WorkerJob, handle: WorkerHandle) -> dict[str, Any]:
         "paneId": handle.pane_id,
         "degradedFrom": handle.degraded_from,
     }
+    return details
+
+
+def _event_execution_identity(job: WorkerJob, attempt: int) -> dict[str, Any]:
+    if job.has_execution_identity:
+        return {
+            "participantRef": job.participant_ref,
+            "roleExecutionRef": job.role_execution_ref,
+            "executionLabel": job.execution_label,
+            "dutyId": job.duty_id,
+            "invocationRef": job.invocation_ref,
+            "attempt": attempt,
+        }
+    return {"workerId": job.worker_id, "attempt": attempt}
 
 
 def _result_details(job: WorkerJob, attempt: int, outcome: WorkerOutcome) -> dict[str, Any]:
     return {
-        "workerId": job.worker_id,
-        "attempt": attempt,
+        **_event_execution_identity(job, attempt),
         "dispatchMode": BACKEND_CLI_WRAPPER if outcome.degraded_from else job.backend,
         "missingCompletionPaths": [],
         # A collected result can still come from a wrapper that exited non-zero
@@ -1570,8 +2615,7 @@ def _failure_details(
     exit_code: int | None = None,
 ) -> dict[str, Any]:
     return {
-        "workerId": job.worker_id,
-        "attempt": attempt,
+        **_event_execution_identity(job, attempt),
         "maxAttempts": MAX_WORKER_ATTEMPTS,
         "dispatchMode": BACKEND_CLI_WRAPPER if outcome.degraded_from else job.backend,
         "exitCode": outcome.returncode if exit_code is None else exit_code,
@@ -1587,8 +2631,7 @@ def _failure_details(
 
 def _retry_details(job: WorkerJob, attempt: int, outcome: WorkerOutcome) -> dict[str, Any]:
     return {
-        "workerId": job.worker_id,
-        "attempt": attempt,
+        **_event_execution_identity(job, attempt),
         "missingCompletionPaths": [str(path) for path in outcome.missing_completion_paths],
         "reason": "required worker artifact was not produced",
     }
@@ -1607,8 +2650,13 @@ def _outcome_from_status(record: Mapping[str, Any], status) -> WorkerOutcome:
 
 
 def _job_from_record(project_root: Path, record: Mapping[str, Any]) -> WorkerJob:
+    identity = _worker_execution_identity(record)
     return WorkerJob(
-        worker_id=_require_string(record, "workerId"),
+        worker_id=(
+            _require_string(record, "workerId")
+            if identity is None
+            else _v2_worker_state_key(record)
+        ),
         provider=_require_string(record, "provider"),
         backend=BACKEND_CLI_WRAPPER,
         project_root=project_root,
@@ -1643,6 +2691,7 @@ def _job_from_record(project_root: Path, record: Mapping[str, Any]) -> WorkerJob
             else None
         ),
         enforcement_mode=_string_value(record.get("enforcementMode")),
+        **(identity or {}),
     )