okstra 0.173.0 → 0.175.1

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -10,18 +10,18 @@ from pathlib import Path
 from typing import Any, Mapping, Sequence
 
 from . import cmux
-from . import tmux
 from .dispatch_state import (
     BACKEND_CLI_WRAPPER,
     BACKEND_CMUX_PANE,
     BACKEND_MIXED,
-    BACKEND_TMUX_PANE,
     append_worker_dispatch as _append_worker_dispatch,
+    build_dispatch_id as _build_dispatch_id,
     DispatchError,
     WorkerJob,
     dispatch_completion_paths as _completion_paths,
     dispatch_mode as _dispatch_mode,
     dispatch_result_path as _result_path_for_worker,
+    dispatch_session_id as _dispatch_session_id,
     LIVENESS_AUDIT_HEARTBEAT,
     LIVENESS_WRAPPER_STATUS,
     load_json_object as _load_json_object,
@@ -39,10 +39,36 @@ 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 .domain.host import HostSessionContext
+from .domain.provider import HostModelBinding, ServedModelAttestation
+from .domain.worker_exec import SERVED_MODEL_MISMATCH_EXIT_CODE
+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 +78,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 +99,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 +120,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 +224,11 @@ 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
 
 
 @dataclass(frozen=True)
@@ -203,6 +340,9 @@ def build_dispatch_plan(
             requested_workers,
             options,
         )
+    # Ahead of the per-prompt checks: a batch the lead must split is a plan-shape
+    # problem, and reporting a prompt-header error for a doomed batch buries it.
+    _validate_implementation_phase_order(jobs)
     _validate_dispatch_prompts(manifest, active_context, jobs)
     _reject_stale_schema_excerpt(project_root, manifest, jobs)
     return DispatchPlan(
@@ -219,12 +359,14 @@ def build_dispatch_plan(
 
 def dispatch_plan(plan: DispatchPlan, *, wait: bool = True) -> int:
     _validate_report_writer_isolation(plan.jobs)
+    _validate_implementation_phase_order(plan.jobs)
+    _revalidate_plan_role_executions(plan)
     if wait:
         pane_backends = sorted(
             {
                 job.backend
                 for job in plan.jobs
-                if job.backend in (BACKEND_TMUX_PANE, BACKEND_CMUX_PANE)
+                if job.backend == BACKEND_CMUX_PANE
             }
         )
         if pane_backends:
@@ -250,12 +392,44 @@ def dispatch_cli_wrapper_plan(plan: DispatchPlan) -> int:
     if any(job.backend != BACKEND_CLI_WRAPPER for job in plan.jobs):
         raise DispatchError("concurrent CLI dispatch requires cli-wrapper jobs only")
     _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)
@@ -267,6 +441,55 @@ def _validate_report_writer_isolation(jobs: Sequence[WorkerJob]) -> None:
         )
 
 
+def _validate_implementation_phase_order(jobs: Sequence[WorkerJob]) -> None:
+    """Keep the executor and the verifiers in two dispatches, never one batch.
+
+    A verifier reads the diff the executor wrote, so `implementation.md` binds
+    its contract to the window "between Executor stage completion and the first
+    verifier dispatch". Nothing enforced that ordering: one
+    `okstra team dispatch --workers claude,codex` started both at once and the
+    verifier observed base HEAD instead of the stage diff, which is what its
+    result then reported on.
+
+    The refusal names the worker IDs on both sides because the second dispatch
+    has to drop the executor's ID: `worker_prompt_policy` re-materializes that
+    ID as the executor every time, so a `--workers` list that keeps it is
+    refused again and a message saying only "split the batch" would loop.
+
+    `build_dispatch_plan` is the only call every production dispatch takes, and
+    the one `--dry-run` stops at, so it is what makes the preview refuse. The
+    two dispatch entry points are public and take a caller-assembled plan, so
+    they check it again there rather than trust their input.
+    """
+    executors = [
+        job.worker_id for job in jobs if job.audience == "implementation-executor"
+    ]
+    verifiers = [
+        job.worker_id for job in jobs if job.audience == "implementation-verifier"
+    ]
+    if executors and verifiers:
+        executor_ids = ", ".join(executors)
+        raise DispatchError(
+            "an implementation batch may not hold the executor and a verifier: "
+            f"{_named_role(executors, 'executor')}, "
+            f"{_named_role(verifiers, 'verifier')}. "
+            "Dispatch the executor alone, settle it with `okstra team await`, "
+            f"then dispatch the verifiers with `--workers` omitting {executor_ids} "
+            "— that worker ID materializes as the executor again, so a second "
+            "batch holding it is refused too. The split is what lets a verifier "
+            "observe the stage diff instead of base HEAD"
+        )
+
+
+def _named_role(worker_ids: Sequence[str], role: str) -> str:
+    """`verifier codex` for one, `verifiers codex, antigravity` for several.
+
+    A roster that adds antigravity puts two verifiers in the same refusal, and
+    a singular label there reads as one worker named "codex, antigravity".
+    """
+    return f"{role}{'s' if len(worker_ids) > 1 else ''} {', '.join(worker_ids)}"
+
+
 def _dispatch_cli_wrapper_batch(
     plan: DispatchPlan,
     jobs: Sequence[WorkerJob],
@@ -274,15 +497,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(
@@ -290,7 +558,9 @@ def _dispatch_cli_wrapper_batch(
                     active,
                     starting_job,
                     starting_attempt,
-                    pending,
+                    prepared,
+                    snapshot,
+                    policies,
                     exc,
                 )
             raise
@@ -307,17 +577,24 @@ def _dispatch_cli_wrapper_batch(
         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",
                     _retry_details(job, attempt, outcome),
                 )
-                next_round.append((job, attempt + 1))
+                next_round.append((_job_for_next_attempt(job), attempt + 1))
                 continue
             final_codes[job.worker_id] = outcome.returncode or 1
         pending = next_round
@@ -330,6 +607,8 @@ 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:
     reason = f"concurrent CLI batch launch failed: {error}"
@@ -341,15 +620,11 @@ def _abort_cli_batch_start(
         process = handle.running_process
         if process is not None:
             process.wait()
-        _transition_worker_status(
-            plan.team_state_path, handle.job.worker_id, "error", reason
-        )
+        _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,
@@ -357,12 +632,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,
@@ -378,18 +660,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,
@@ -398,6 +683,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(
@@ -443,6 +742,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,
@@ -479,6 +787,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,
@@ -510,6 +830,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],
@@ -588,7 +1080,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,
@@ -608,6 +1100,7 @@ def _job_from_roster_worker(
         role=fact.role,
         idle_timeout_seconds=options.idle_timeout_seconds,
         dispatch_kind=options.dispatch_kind,
+        session_id=_dispatch_session_id(fact.provider),
         **invocation,
     )
 
@@ -622,6 +1115,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 {}
@@ -632,7 +1126,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"),
@@ -647,6 +1141,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(
@@ -668,7 +1193,7 @@ def _materialize_roster_prompts(
                 project_root=project_root,
                 run_manifest_path=manifest_path,
                 runtime_root=workspace_root,
-                delivery_mode=_delivery_mode(options.default_backend),
+                delivery_mode=PromptDeliveryMode.EAGER_INCLUDE,
                 workers=tuple(
                     InitialPromptWorkerRequest(fact.worker_id, fact.model)
                     for fact in worker_facts
@@ -696,12 +1221,6 @@ def _roster_worker_facts(
     )
 
 
-def _delivery_mode(default_backend: str) -> PromptDeliveryMode:
-    if default_backend == BACKEND_TMUX_PANE:
-        return PromptDeliveryMode.LAZY_PATH_REFERENCE
-    return PromptDeliveryMode.EAGER_INCLUDE
-
-
 def _jobs_from_file(
     project_root: Path,
     workspace_root: Path,
@@ -726,34 +1245,50 @@ 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", "",
-        model_execution_value=job.model_execution_value,
-    )
     process: subprocess.Popen[str] | None = None
     try:
         process = subprocess.Popen(job.command, cwd=plan.project_root, text=True)
         handle = WorkerHandle(
             job, "", None, status_path_for_prompt(job.prompt_path), "", process
         )
-        _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:
@@ -762,16 +1297,219 @@ def _spawn_cli_job_nonblocking(
         raise
 
 
+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,
+    )
+    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:
+        enforcement = write_enforcement_from_payload(
+            invocation.write_enforcement
+        )
+        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:
     for attempt in range(1, MAX_WORKER_ATTEMPTS + 1):
         handle = _spawn_job(plan, job, attempt)
         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
         return outcome.returncode or 1
     return 1
@@ -780,8 +1518,6 @@ def _dispatch_job_with_retry(plan: DispatchPlan, job: WorkerJob) -> int:
 def _start_job(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
     if job.backend == BACKEND_CLI_WRAPPER:
         return _run_cli_wrapper(plan, job, "")
-    if job.backend == BACKEND_TMUX_PANE:
-        return _start_tmux_or_degrade(plan, job)
     if job.backend == BACKEND_CMUX_PANE:
         return _start_cmux_or_degrade(plan, job)
     raise DispatchError(f"unsupported worker backend: {job.backend}")
@@ -797,7 +1533,11 @@ def _start_cmux_or_degrade(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
             workspace=workspace,
             cwd=plan.project_root,
             command=job.command,
-            title=f"{job.worker_id}-worker",
+            title=(
+                job.execution_label
+                if job.has_execution_identity
+                else f"{job.worker_id}-worker"
+            ),
             owned_surface_ids=_opened_cmux_surfaces(plan.team_state_path),
         )
     except (RuntimeError, OSError, subprocess.SubprocessError):
@@ -829,23 +1569,6 @@ def _opened_cmux_surfaces(team_state_path: Path) -> tuple[str, ...]:
     return tuple(opened)
 
 
-def _start_tmux_or_degrade(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
-    lead_pane = tmux.resolve_caller_pane()
-    if not lead_pane:
-        return _run_cli_wrapper(plan, job, BACKEND_TMUX_PANE)
-    try:
-        pane_id = tmux.split_worker_pane(
-            target_pane=lead_pane,
-            cwd=plan.project_root,
-            command=job.command,
-            title=f"{job.worker_id}-worker",
-            run_dir=_run_dir(plan),
-        )
-    except RuntimeError:
-        return _run_cli_wrapper(plan, job, BACKEND_TMUX_PANE)
-    return WorkerHandle(job, pane_id, None, status_path_for_prompt(job.prompt_path), "")
-
-
 def _refuse_when_cmux_is_walled_off() -> None:
     """Stop rather than degrade when a sandbox stands between okstra and cmux.
 
@@ -933,16 +1656,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"
@@ -950,22 +1674,47 @@ 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
     )
     _append_event(plan, "worker-retry-scheduled", details)
-    _spawn_job(plan, job, attempt + 1)
+    # The restored job settles attempt 1 above and must keep its session; only
+    # the attempt being opened here gets a new one.
+    _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,
@@ -982,10 +1731,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,
@@ -998,16 +1746,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(
@@ -1038,7 +1918,7 @@ def _link_result(
         _link_agent_dispatch_result(
             project_root=plan.project_root,
             run_manifest_path=plan.manifest_path,
-            dispatch_id=f"{job.invocation_id}:attempt-{attempt}",
+            dispatch_id=_build_dispatch_id(job.invocation_id, attempt),
             result_path=job.worker_result_path,
         )
     except (DispatchError, OSError) as exc:
@@ -1047,9 +1927,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)
@@ -1087,7 +1992,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 = (
@@ -1181,6 +2090,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}"
@@ -1189,6 +2103,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.
 
@@ -1267,9 +2192,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(
@@ -1284,15 +2287,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,
@@ -1300,6 +2319,10 @@ def _dispatch_record(
         "provider": job.provider,
         "status": status,
         "paneId": pane_id,
+        # The only handle on a pane worker's transcript: it runs as its own
+        # `claude -p` process and leaves no `agentName` in its session jsonl, so
+        # token collection resolves its usage by this value or not at all.
+        "sessionId": job.session_id,
         "promptPath": str(job.prompt_path),
         "resultPath": str(job.result_path),
         "workerResultPath": str(job.worker_result_path),
@@ -1317,7 +2340,7 @@ def _dispatch_record(
     }
     if job.invocation_id:
         record.update({
-            "dispatchId": f"{job.invocation_id}:attempt-{attempt}",
+            "dispatchId": _build_dispatch_id(job.invocation_id, attempt),
             "invocationId": job.invocation_id,
             "audience": job.audience,
             "assignmentRef": job.assignment_ref,
@@ -1326,11 +2349,32 @@ 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
 
 
 def _liveness_mode(backend: str) -> str:
-    if backend in (BACKEND_CLI_WRAPPER, BACKEND_TMUX_PANE, BACKEND_CMUX_PANE):
+    if backend in (BACKEND_CLI_WRAPPER, BACKEND_CMUX_PANE):
         return LIVENESS_WRAPPER_STATUS
     return LIVENESS_AUDIT_HEARTBEAT
 
@@ -1463,7 +2507,9 @@ def _relay_to_sidebar(plan: DispatchPlan, event_type: str, details: Mapping[str,
     if plan.default_backend != BACKEND_CMUX_PANE:
         return
     workspace = cmux.resolve_lead_workspace()
-    worker_id = str(details.get("workerId", "") or "worker")
+    worker_id = str(
+        details.get("executionLabel") or details.get("workerId") or "worker"
+    )
     cmux.sidebar_log(
         workspace,
         f"{worker_id}: {event_type.removeprefix('worker-')}",
@@ -1494,13 +2540,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),
@@ -1509,12 +2558,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
@@ -1533,8 +2595,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,
@@ -1550,8 +2611,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",
     }
@@ -1570,8 +2630,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,
@@ -1585,6 +2650,10 @@ def _job_from_record(project_root: Path, record: Mapping[str, Any]) -> WorkerJob
         role=_require_string(record, "role"),
         idle_timeout_seconds=600,
         dispatch_kind=_require_string(record, "kind"),
+        # Restored, never re-issued: both callers rebuild a job from its record
+        # to settle a dispatch that already ran, and a fresh id would settle it
+        # against a session that never existed.
+        session_id=_string_value(record.get("sessionId")),
         invocation_id=_string_value(record.get("invocationId")),
         audience=_string_value(record.get("audience")),
         assignment_ref=_string_value(record.get("assignmentRef")),
@@ -1602,6 +2671,7 @@ def _job_from_record(project_root: Path, record: Mapping[str, Any]) -> WorkerJob
             else None
         ),
         enforcement_mode=_string_value(record.get("enforcementMode")),
+        **(identity or {}),
     )
 
 
@@ -1613,6 +2683,20 @@ def _should_retry(outcome: WorkerOutcome, attempt: int) -> bool:
     return outcome.returncode == 0 and bool(outcome.missing_completion_paths) and attempt < MAX_WORKER_ATTEMPTS
 
 
+def _job_for_next_attempt(job: WorkerJob) -> WorkerJob:
+    """The same work as a new attempt, which means a new session.
+
+    The first attempt's process is dead; a retry starts another one. Carrying
+    the id over would merge two processes into one attribution unit, and it
+    would hand `claude --session-id` a value that is already taken — behaviour
+    the CLI does not document. Every re-dispatch goes through here so no path
+    can quietly keep the old session.
+
+    A provider with no session flag gets '' back, so this is a no-op for it.
+    """
+    return replace(job, session_id=_dispatch_session_id(job.provider))
+
+
 def _failure_reason(outcome: WorkerOutcome) -> str:
     if outcome.timeout:
         return "worker wrapper timed out"
@@ -1709,11 +2793,6 @@ def _reject_stale_schema_excerpt(
     )
 
 
-def _run_dir(plan: DispatchPlan) -> Path:
-    value = _string_value(plan.manifest.get("runDirectoryPath"))
-    return _resolve_project_path(plan.project_root, value) if value else plan.team_state_path.parent.parent
-
-
 def _load_optional_json(project_root: Path, value: Any) -> dict[str, Any]:
     if not isinstance(value, str) or not value.strip():
         return {}