okstra 0.202.0 → 0.204.0

package/runtime/python/okstra_ctl/contract_refreeze.py

@@ -0,0 +1,156 @@
+"""진행 중인 run 의 동결 계약을 현재 형식으로 다시 동결한다.
+
+run 은 시작할 때 직무·역할·공통 계약을 자기 폴더로 동결하고, 그 다이제스트를
+매니페스트에 적는다. 계약 형식이 바뀐 릴리스를 설치하면 그 run 의 다이제스트는
+새 규칙으로 계산한 값과 영영 다르고, 프롬프트를 하나도 더 만들 수 없다 — 실측
+2026-09-23(fontradar-v2-api dev-10860 implementation-planning-002): 같은 run 에서
+8회 성공한 뒤 설치가 한 번 일어나자 그다음 materialize 가
+`run duty snapshot catalog digest does not match` 로 멈췄다.
+
+이 모듈은 그 run 을 현재 형식으로 다시 동결하고 매니페스트의 다이제스트와 형식
+표식을 갱신한다. 계약 본문은 런타임이 소유하므로 새로 쓰는 것이 원래 값이고,
+run 의 증거(프롬프트·결과·원장)는 건드리지 않는다. 사용자가 명시적으로 부를 때만
+도는 복구 경로다.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+
+from .agent.invocation import digest_duty_catalog
+from .json_boundary import (
+    JsonBoundaryError,
+    load_owned_object,
+    write_owned_object_atomic,
+)
+from .run import (
+    CONTRACT_FORMAT_VERSION,
+    PrepareError,
+    _common_contract_source,
+    _duty_catalog_source,
+)
+
+
+class ContractRefreezeError(RuntimeError):
+    """다시 동결할 수 없는 run. 메시지가 그 자리를 이름한다."""
+
+
+@dataclass(frozen=True)
+class RefreezeResult:
+    duty_root: str
+    previous_digest: str
+    digest: str
+    previous_format_version: int
+    format_version: int
+    changed: bool
+
+
+def frozen_format_version(contract: Mapping[str, Any]) -> int:
+    """이 run 이 동결한 계약 형식. 표식이 없는 run 은 1(Markdown 직무)이다."""
+    value = contract.get("contractFormatVersion")
+    return value if isinstance(value, int) and not isinstance(value, bool) else 1
+
+
+def refreeze_message(duty_root: str) -> str:
+    """형식이 어긋난 run 이 받아야 할 문장 — 원인과 다음 명령."""
+    return (
+        "run froze an older duty contract format and this install cannot read "
+        f"it: {duty_root}. Re-freeze this run's contracts with "
+        "`okstra agent-prompt refreeze-contracts --project-root <dir> "
+        "--run-manifest <path>`, then repeat the command that failed."
+    )
+
+
+def refreeze_run_contracts(
+    *, project_root: Path, run_manifest_path: Path, workspace_root: Path,
+) -> RefreezeResult:
+    """이 run 의 계약 폴더를 현재 런타임 카탈로그로 갈아 끼운다."""
+    root = project_root.resolve()
+    manifest_path = _resolve(root, run_manifest_path)
+    manifest = _load(manifest_path, "run manifest")
+    contract = manifest.get("agentContract")
+    if not isinstance(contract, dict):
+        raise ContractRefreezeError(f"run manifest has no agentContract: {manifest_path}")
+    duty_root_rel = str(contract.get("dutyRootPath") or "")
+    if not duty_root_rel:
+        raise ContractRefreezeError(f"agentContract has no dutyRootPath: {manifest_path}")
+    duty_root = _resolve(root, Path(duty_root_rel))
+    previous_digest = str(contract.get("catalogDigest") or "")
+    previous_format = frozen_format_version(contract)
+    try:
+        source = _duty_catalog_source(workspace_root)
+        common_source = _common_contract_source(workspace_root)
+    except PrepareError as exc:
+        raise ContractRefreezeError(str(exc)) from exc
+    digest = _replace_snapshot(duty_root, source, common_source)
+    changed = (
+        digest != previous_digest or previous_format != CONTRACT_FORMAT_VERSION
+    )
+    if changed:
+        contract["catalogDigest"] = digest
+        contract["contractFormatVersion"] = CONTRACT_FORMAT_VERSION
+        _write_manifest(manifest_path, manifest)
+    return RefreezeResult(
+        duty_root=str(duty_root),
+        previous_digest=previous_digest,
+        digest=digest,
+        previous_format_version=previous_format,
+        format_version=CONTRACT_FORMAT_VERSION,
+        changed=changed,
+    )
+
+
+def _replace_snapshot(duty_root: Path, source: Path, common_source: Path) -> str:
+    """계약 폴더를 통째로 새로 쓴다. 옛 형식 파일은 남기지 않는다.
+
+    옛 파일을 남기면 두 형식이 한 폴더에 섞이고, 다이제스트가 세는 대상과 로더가
+    읽는 대상이 다시 갈린다 — 이 결함이 처음 생긴 자리가 그 갈림이다.
+    """
+    duty_root.parent.mkdir(parents=True, exist_ok=True)
+    staged = Path(tempfile.mkdtemp(
+        dir=duty_root.parent, prefix=f".{duty_root.name}.", suffix=".refreeze",
+    ))
+    retired = duty_root.with_name(f".{duty_root.name}.retired")
+    try:
+        shutil.copytree(source, staged, dirs_exist_ok=True)
+        shutil.copyfile(common_source, staged / "common.json")
+        shutil.copytree(
+            common_source.parent / "roles", staged / "roles", dirs_exist_ok=True
+        )
+        digest = digest_duty_catalog(staged)
+        if duty_root.exists():
+            shutil.rmtree(retired, ignore_errors=True)
+            os.rename(duty_root, retired)
+        os.rename(staged, duty_root)
+    except OSError as exc:
+        raise ContractRefreezeError(f"cannot re-freeze duty contracts: {exc}") from exc
+    finally:
+        shutil.rmtree(staged, ignore_errors=True)
+        shutil.rmtree(retired, ignore_errors=True)
+    return digest
+
+
+def _resolve(project_root: Path, value: Path) -> Path:
+    path = Path(value).expanduser()
+    return path if path.is_absolute() else project_root / path
+
+
+def _load(path: Path, label: str) -> dict[str, Any]:
+    try:
+        payload = load_owned_object(path, artifact=label)
+    except (OSError, JsonBoundaryError) as exc:
+        raise ContractRefreezeError(f"cannot read {label} {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise ContractRefreezeError(f"{label} is not an object: {path}")
+    return payload
+
+
+def _write_manifest(path: Path, manifest: Mapping[str, Any]) -> None:
+    try:
+        write_owned_object_atomic(path, manifest, artifact="run manifest")
+    except JsonBoundaryError as exc:
+        raise ContractRefreezeError(f"cannot write run manifest {path}: {exc}") from exc

package/runtime/python/okstra_ctl/convergence_provenance.py

@@ -154,7 +154,13 @@ def worker_result_paths(
         if candidate.resolve().parent != results_dir.resolve():
             raise ValueError(f"accepted resultPath is outside worker-results: {candidate}")
         if not candidate.is_file():
-            raise ValueError(f"accepted resultPath is missing: {candidate}")
+            # 이 모듈의 계약은 "없는 워커 결과는 조용히 건너뛴다" 이고, 그 판정은
+            # 아래 `read_canonical_worker_result` 가 None 을 돌려주는 것으로
+            # 이루어진다. 여기서 던지면 판정이 아니라 run 이 죽는다 — 실측
+            # 2026-09-23(jobs dev-10860 stage 1): 옛 run 의 원장이 ok 로 적은
+            # 결과 파일이 디스크에 없어 `report-finalize --only validate-run` 이
+            # 예외로 멈췄다. 파일명 규칙 경로를 그대로 두고 넘어간다.
+            continue
         paths[row["workerId"]] = candidate
     return paths
 

package/runtime/python/okstra_ctl/design_prep.py

@@ -20,6 +20,7 @@ from fnmatch import fnmatchcase
 from pathlib import Path
 from typing import Any, Iterator
 
+from .consumers import read_stage_consumer_state
 from .final_report_schema import load_schema, validate as validate_schema
 from .json_boundary import JsonBoundaryError, load_owned_object
 from okstra_project import ResolverError, resolve_project_root
@@ -466,6 +467,7 @@ def materialize_design_prep_requests(plan_data_path: Path) -> list[Path]:
     # 충돌은 한 항목씩 알리지 않는다. 요청 12개가 모두 옛 리포트의 파일과 부딪히면
     # 첫 건에서 멈추는 구현은 사용자에게 12회 왕복을 시키고, 그때마다 이미 쓴
     # 앞쪽 파일이 남아 상태가 절반만 진행된다. 전부 렌더해 전부 검사한 뒤 쓴다.
+    done = _done_stages(data_path)
     rendered = [
         _render_request(
             data_path=data_path,
@@ -474,7 +476,7 @@ def materialize_design_prep_requests(plan_data_path: Path) -> list[Path]:
             item=item,
         )
         for item in items
-        if item.get("status") in _REQUEST_STATUSES
+        if item.get("status") in _REQUEST_STATUSES and not _is_implemented(item, done)
     ]
     conflicts = [
         reason
@@ -494,6 +496,37 @@ def materialize_design_prep_requests(plan_data_path: Path) -> list[Path]:
     return written
 
 
+def _done_stages(data_path: Path) -> frozenset[int]:
+    """이 태스크에서 이미 구현이 끝난 stage.
+
+    원장을 못 읽으면 빈 집합이다 — 그때의 동작은 이 판정이 없던 때와 같고,
+    "모르니까 건너뛴다" 는 반대 방향의 실패보다 안전하다.
+    """
+    try:
+        state = read_stage_consumer_state(data_path.parent.parent)
+    except (OSError, UnicodeError, ValueError):
+        return frozenset()
+    return frozenset(state.done_stages)
+
+
+def _is_implemented(item: Mapping[str, Any], done: frozenset[int]) -> bool:
+    """이 항목이 가리키는 stage 가 전부 구현 완료인가.
+
+    구현이 끝난 stage 의 계획은 역사이지 계획이 아니다. 그런데 탐지기는 매
+    계획 run 마다 이월된 stage 본문을 다시 훑고, 그 사이 선택 방향의
+    `fileStructure` 가 바뀌면 같은 PREP 항목이 다른 증거로 렌더된다. 요청
+    파일은 태스크 단위 이름이라 불변 파일과 충돌하고, report-finalize 는
+    빠져나갈 길 없이 멈춘다(2026-09-24, dev-10860: 9건). 이미 지어진 것에
+    설계 준비를 다시 요구하는 것이므로, 답도 쓸모가 없다.
+    """
+    stages = [
+        stage
+        for stage in item.get("stageRefs") or ()
+        if isinstance(stage, int) and not isinstance(stage, bool)
+    ]
+    return bool(stages) and all(stage in done for stage in stages)
+
+
 def load_design_prep_items(report_path: Path) -> tuple[dict[str, Any], ...]:
     """Return validated snapshot items without exposing mutable report data."""
     data_path = _canonical_data_path(report_path)

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -96,6 +96,7 @@ from .initial_prompt_materialization import (
     InitialPromptMaterializationRequest,
     InitialPromptWorkerRequest,
     PromptDeliveryMode,
+    declared_delivery_mode,
     materialize_initial_prompts,
 )
 from .agent.invocation import AgentInvocationError, materialize_retry_invocation
@@ -183,6 +184,9 @@ def revalidate_role_execution(
                 interaction_surface="role-execution-dispatch",
             ),
             environment=host,
+            # 이 run 은 이 모델을 이미 골랐다. 지금 고를 수 있는지가 아니라 그
+            # 배정이 그대로 실행 가능한지를 묻는 자리다.
+            require_selectable=False,
         )
         binding = assignment.binding
         if binding is None:
@@ -261,6 +265,7 @@ class WorkerHandle:
     completed_process: subprocess.CompletedProcess[str] | None
     status_sidecar_path: Path | None
     degraded_from: str
+    degraded_reason: str = ""
     running_process: subprocess.Popen[str] | None = None
     mutation_snapshot: MutationSnapshot | None = None
     mutation_policies: tuple[WritePolicy, ...] = ()
@@ -1439,31 +1444,11 @@ def _invocation_job_fields(
 def _initial_prompt_delivery_mode(
     manifest: Mapping[str, Any],
 ) -> PromptDeliveryMode:
-    """이 run 의 어댑터가 선언한 초기 프롬프트 배송 방식.
-
-    선언은 `leadAdapter.initialPromptDeliveryMode` 에 있고, 그 값은 render 가
-    호스트 descriptor(어댑터가 워커 디스패치를 가져갔으면 그 어댑터)에서
-    옮겨 적은 것이다. 선언이 없는 매니페스트는 이 필드가 생기기 전에 준비된
-    run 이므로 그때의 동작인 `eager-include` 로 간다. 아는 값이 아니면 멈춘다 —
-    프롬프트를 발행하고 나면 그 프롬프트는 불변이라, 잘못 고른 배송 방식은
-    나중에 고칠 수 없다.
-    """
-    adapter = manifest.get("leadAdapter")
-    declared = (
-        _string_value(adapter.get("initialPromptDeliveryMode"))
-        if isinstance(adapter, Mapping)
-        else ""
-    )
-    if not declared:
-        return PromptDeliveryMode.EAGER_INCLUDE
+    """이 run 의 초기 프롬프트 배송 방식. 판정은 `declared_delivery_mode` 가 한다."""
     try:
-        return PromptDeliveryMode(declared)
-    except ValueError:
-        allowed = ", ".join(mode.value for mode in PromptDeliveryMode)
-        raise DispatchError(
-            "leadAdapter.initialPromptDeliveryMode is not a delivery mode: "
-            f"{declared!r} (allowed: {allowed})"
-        ) from None
+        return declared_delivery_mode(manifest)
+    except InitialPromptMaterializationError as exc:
+        raise DispatchError(str(exc)) from None
 
 
 def _materialize_roster_prompts(
@@ -2034,8 +2019,20 @@ def _start_job(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
         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
+    if degraded_from:
+        print(
+            f"DEGRADED {job.role}: {degraded_from} -> {runtime.surface} "
+            f"({runtime.fallback_reason or 'no reason reported'})",
+            flush=True,
+        )
     completed = None
-    if runtime.waitable:
+    # 강등된 job 은 여기서 기다리지 않는다. `dispatch_plan` 은 wait=True 에서
+    # pane job 을 거절하므로(같은 함수의 pane_backends 검사) 강등은 비차단 배치
+    # 에서만 일어난다. 그 배치에서 기다리면 라운드가 직렬화되고 — 실측 2026-09-21,
+    # 워커 3명이 병렬 대신 37분 — dispatch 행이 워커가 끝난 뒤에야 써져
+    # `okstra worker-liveness` 가 실행 중인 워커를 모른다. 정산은 상태 사이드카를
+    # 읽는 `await_dispatches` 가 맡는다.
+    if runtime.waitable and not degraded_from:
         from .adapters.runtime.assembly import port_for
         returncode = port_for(plan.runtime_chain, runtime.surface).wait(runtime)
         completed = subprocess.CompletedProcess(list(settled.command), returncode)
@@ -2046,6 +2043,7 @@ def _start_job(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
         completed,
         status_path_for_prompt(settled.prompt_path),
         degraded_from,
+        degraded_reason=runtime.fallback_reason,
         runtime_handle=runtime,
         started_at=started_at,
     )
@@ -2237,9 +2235,28 @@ def _retry_from_record(
 # 사유 한 줄에 실을 경로 개수. 전부 실으면 team-state 행이 부풀고, 하나도 안
 # 실으면 읽는 쪽이 다른 파일을 뒤져야 한다.
 _MUTATION_REASON_PATH_LIMIT = 5
+# 사유는 team-state 의 한 행이다. 래퍼 실패 문장은 길 수 있으므로 자른다.
+_MUTATION_REASON_FAILURE_LIMIT = 200
+
+
+def _wrapper_failure_text(outcome: WorkerOutcome | None) -> str:
+    """워커 래퍼가 남긴 실패 문장. 없으면 빈 문자열.
+
+    `mutation-present-unresolved` 는 "시도가 실패했는데 소스가 바뀌어 있다" 는
+    뜻이고, 왜 실패했는지는 상태 사이드카에만 있었다. 읽는 쪽은 상태 이름만 보고
+    소스를 뒤져야 했다 — 실측 2026-09-23: 두 세션이 같은 자리에서 그렇게
+    진단했고, 원인은 카탈로그에 없는 served 모델이었다.
+    """
+    if outcome is None or outcome.status_sidecar_path is None:
+        return ""
+    status = read_wrapper_status(outcome.status_sidecar_path)
+    if status is None:
+        return ""
+    failure = _string_value(status.raw.get("failure"))
+    return failure[:_MUTATION_REASON_FAILURE_LIMIT]
 
 
-def _mutation_failure_reason(mutation) -> str:
+def _mutation_failure_reason(mutation, outcome: WorkerOutcome | None = None) -> str:
     """왜 실패했는지와 무엇이 바뀌었는지를 한 줄에 담는다.
 
     종전에는 디스패치 행에 `readonly source changed` 만 남고 바뀐 경로는
@@ -2249,6 +2266,9 @@ def _mutation_failure_reason(mutation) -> str:
     사유 옆에 놓는다.
     """
     reason = "; ".join(mutation.violations) or mutation.status
+    failure = _wrapper_failure_text(outcome)
+    if failure:
+        reason = f"{reason}: {failure}"
     paths = list(mutation.changed_paths)
     if not paths:
         return reason
@@ -2273,7 +2293,7 @@ def _finish_attempt(
         "contract-failed-unattributed",
         "mutation-present-unresolved",
     }:
-        reason = _mutation_failure_reason(mutation)
+        reason = _mutation_failure_reason(mutation, outcome)
         _update_dispatch_status(
             plan.team_state_path, job, attempt, "error", reason
         )
@@ -2913,6 +2933,7 @@ def _record_dispatch(
             handle.pane_id,
             handle.degraded_from,
             reason,
+            degraded_reason=handle.degraded_reason,
             mutation_snapshot_path=(
                 _mutation_snapshot_path(handle.job)
                 if handle.mutation_snapshot is not None
@@ -2932,6 +2953,7 @@ def _dispatch_record(
     degraded_from: str,
     reason: str = "",
     *,
+    degraded_reason: str = "",
     mutation_snapshot_path: Path | None = None,
     write_policy_digest: str = "",
     write_enforcement: WriteEnforcement | None = None,
@@ -2958,6 +2980,9 @@ def _dispatch_record(
         ),
         "statusSidecarPath": str(status_path_for_prompt(job.prompt_path)),
         "degradedFrom": degraded_from,
+        # `reason` 은 이 행의 정산 사유라 마감과 teardown 이 덮어쓴다. 강등 사유는
+        # 디스패치 시점의 사실이므로 자기 칸을 쓴다.
+        "degradedReason": degraded_reason,
         "reason": reason,
         "modelExecutionValue": job.model_execution_value,
         "wrapperPath": str(job.wrapper_path),
@@ -3186,6 +3211,7 @@ def _event_details(job: WorkerJob, handle: WorkerHandle) -> dict[str, Any]:
         "role": job.role,
         "paneId": handle.pane_id,
         "degradedFrom": handle.degraded_from,
+        "degradedReason": handle.degraded_reason,
     }
     return details
 

package/runtime/python/okstra_ctl/domain/host.py

@@ -51,6 +51,11 @@ class HostDescriptor:
     session_accounting: str
     has_claude_session: bool
     relay_contract: str
+    # 이 호스트 세션 안에서 도는 워커(runner=native-session)가 읽어야 하는
+    # 계약 파일의 절대 경로. 호스트가 그런 계약을 선언하지 않으면 빈 문자열이다.
+    # 호스트 전역 발견 경로에 설치되지 않는다 — 디스패치 프롬프트가 경로로
+    # 전달하고, 워커가 프리앰블과 같은 방식으로 연다.
+    worker_session_contract: str = ""
     # 이 호스트가 초기 워커 프롬프트를 어떻게 싣겠다고 선언하는가. 값은
     # `relay.md` 의 `initialPromptDeliveryMode` 행과 같아야 한다 — 그 표를
     # 읽고 dispatch 를 판단하는 것은 리드이고, 실제로 프롬프트를 만드는 것은

package/runtime/python/okstra_ctl/domain/worker_runtime.py

@@ -31,9 +31,19 @@ class WorkerSpawnRequest:
 
 @dataclass(frozen=True)
 class RuntimeHandle:
+    """An opened surface, and why it is not the one that was planned.
+
+    `fallback_reason` is empty when the planned surface opened. It carries the
+    last `SurfaceUnavailable` message when an earlier surface in the chain was
+    skipped, because that message exists nowhere else: the chain swallows the
+    exception it recovers from, and a degraded dispatch used to be recorded
+    with an empty reason.
+    """
+
     surface: str
     identifier: str
     waitable: bool
+    fallback_reason: str = ""
 
 
 @dataclass(frozen=True)

package/runtime/python/okstra_ctl/error_report.py

@@ -1,8 +1,8 @@
 """Read-side aggregator for okstra-run error logs.
 
 task 의 모든 run errors-<type>-<seq>.jsonl 을 모아 phase / worker / errorType
-별로 집계하고 timestamp 누적 .md 리포트로 렌더한다. task 산출물을 mutate 하지
-않는다.
+별로 집계하고 timestamp 누적 .md 리포트로 렌더한다. 리포트 외에 쓰는 것은
+task 해석 중 `find_task_root` 가 끝난 implementation 결과를 기록하는 경우뿐이다.
 """
 from __future__ import annotations
 
@@ -236,7 +236,8 @@ _CLI_EPILOG = r"""Usage:
 
 Writes a timestamped markdown report under <task-root>/error-reports/ and
 prints a JSON summary (counts by errorType / source / phase / agent) to stdout.
-This is read-only against task state; it never mutates task artifacts.
+Resolving a task may record a finished implementation outcome in its task
+manifest, the task catalog, and consumers.jsonl; nothing else is written.
 """
 
 

package/runtime/python/okstra_ctl/execution_manifest.py

@@ -213,7 +213,9 @@ def reserve_derived_role_invocation(
             raise ExecutionManifestError(
                 f"source role execution is unknown: {source_role_execution_ref}"
             )
-        derived, created = _derived_role_execution(manifest, source, role)
+        derived, created, derived_participant = _derived_role_execution(
+            manifest, source, role
+        )
         invocation = invocation_factory(derived)
         if not isinstance(invocation, Invocation):
             raise ExecutionManifestError("invocation factory must return Invocation")
@@ -244,14 +246,22 @@ def reserve_derived_role_invocation(
                 _write_json_atomic(task_manifest_path, recovered_task_payload)
             return derived, existing_invocation
 
+        base = manifest
+        if created and derived_participant is not None:
+            base = _replace_manifest(
+                manifest,
+                participant_assignments=(
+                    *manifest.participant_assignments,
+                    derived_participant,
+                ),
+            )
         roles = (
-            (*manifest.role_executions, derived)
-            if created
-            else manifest.role_executions
+            (*base.role_executions, derived) if created else base.role_executions
         )
-        with_role = _replace_manifest(manifest, role_executions=roles)
+        with_role = _replace_manifest(base, role_executions=roles)
         if created:
-            _validate_next_role_execution(manifest, derived)
+            # 새 참가자가 실린 뒤라야 참가자 참조 검사가 성립한다.
+            _validate_next_role_execution(base, derived)
         _validate_next_invocation(with_role, invocation)
         updated = _replace_manifest(
             with_role,
@@ -540,11 +550,13 @@ def _validate_roles(
                     "sourceRoleExecutionRef must reference an earlier different "
                     "role execution"
                 )
-            if source_role.get("participantRef") != participant_ref:
-                raise ExecutionManifestError(
-                    "sourceRoleExecutionRef participant must match derived role "
-                    "participant"
-                )
+            # 참가자는 더 이상 공유하지 않는다(ADR-0017). 파생을 파생이게 하는
+            # 것은 같은 모델로 같은 일을 다시 읽는다는 것이므로, 거기를 검사한다.
+            for key in ("provider", "modelRef", "modelId"):
+                if source_role.get(key) != row.get(key):
+                    raise ExecutionManifestError(
+                        f"derived role execution {key} must match its source"
+                    )
         earlier_roles[role_ref] = row
     for role, values in ordinals.items():
         if sorted(values) != list(range(1, len(values) + 1)):
@@ -815,20 +827,29 @@ def _derived_role_execution(
     manifest: ExecutionManifest,
     source: RoleExecution,
     role: str,
-) -> tuple[RoleExecution, bool]:
+) -> tuple[RoleExecution, bool, ParticipantAssignment | None]:
+    """The dynamic role slot derived from *source*, creating it when absent.
+
+    A created slot is its own participant. It copies the source's provider,
+    model and binding — that is what makes it the same model re-reading the
+    same work — but not the source's identity or session. Sharing the
+    participant made the derived slot indistinguishable from its source
+    wherever a participant is what gets attributed or resumed.
+    """
     if source.role == role:
-        return source, False
+        return source, False, None
     existing = [
         item
         for item in manifest.role_executions
-        if item.participant_ref == source.participant_ref and item.role == role
+        if item.source_role_execution_ref == source.role_execution_ref
+        and item.role == role
     ]
     if len(existing) > 1:
         raise ExecutionManifestError(
-            f"participant has multiple {role} role executions: {source.participant_ref}"
+            f"source has multiple {role} role executions: {source.role_execution_ref}"
         )
     if existing:
-        return existing[0], False
+        return existing[0], False, None
     ordinal = max(
         (item.ordinal for item in manifest.role_executions if item.role == role),
         default=0,
@@ -840,9 +861,10 @@ def _derived_role_execution(
         raise ExecutionManifestError(
             f"derived roleExecutionRef is already reserved: {role_ref}"
         )
+    participant = _derived_participant(manifest, source)
     return RoleExecution(
         role_execution_ref=role_ref,
-        participant_ref=source.participant_ref,
+        participant_ref=participant.participant_ref,
         source_role_execution_ref=source.role_execution_ref,
         role=role,
         provider=source.provider,
@@ -859,7 +881,38 @@ def _derived_role_execution(
         binding=source.binding,
         served_model_attestation=ServedModelAttestation.unknown(),
         status="prepared",
-    ), True
+    ), True, participant
+
+
+def _derived_participant(
+    manifest: ExecutionManifest,
+    source: RoleExecution,
+) -> ParticipantAssignment:
+    """A fresh participant carrying the source's model but none of its session."""
+    origin = next(
+        (
+            item
+            for item in manifest.participant_assignments
+            if item.participant_ref == source.participant_ref
+        ),
+        None,
+    )
+    if origin is None:
+        raise ExecutionManifestError(
+            f"source role execution references unknown participant: "
+            f"{source.participant_ref}"
+        )
+    used = {item.participant_ref for item in manifest.participant_assignments}
+    ordinal = len(used) + 1
+    while f"participant-{ordinal:03d}" in used:
+        ordinal += 1
+    return replace(
+        origin,
+        participant_ref=f"participant-{ordinal:03d}",
+        session_ref=None,
+        window_ref=None,
+        status="prepared",
+    )
 
 
 def _validate_next_invocation(manifest: ExecutionManifest, row: Invocation) -> None: