okstra 0.202.0 → 0.205.0

package/runtime/python/okstra_ctl/manager_store.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import json
 import os
+import shutil
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -18,12 +19,17 @@ from okstra_ctl.json_boundary import (
 from .manager_paths import (
     ManagerPathError,
     canonical_manager_id,
+    child_context_path,
     children_json_path,
     directives_jsonl_path,
     events_jsonl_path,
     manager_json_path,
     manager_root,
     projects_json_path,
+    snapshots_json_path,
+    task_group_meta_path,
+    task_group_root,
+    task_groups_root,
     task_manifest_path,
 )
 
@@ -224,11 +230,20 @@ def link_project(
     return payload
 
 
+def _ensure_group_meta(home: Path, manager_id: str, task_group: str, when: str) -> dict:
+    """그룹 폴더와 `group.json` 을 만든다. 이미 있으면 처음 기록을 그대로 둔다."""
+    path = task_group_meta_path(home, manager_id, task_group)
+    if path.is_file():
+        return _read_json(path)
+    meta = {"taskGroup": task_group, "createdAt": when}
+    _write_json(path, meta)
+    return meta
+
+
 def create_task_group(home: Path, manager_id: str, task_group: str, *, now: str | None = None) -> dict:
     load_manager(home, manager_id)
-    group_dir = task_manifest_path(home, manager_id, task_group, "group-marker").parents[1]
-    group_dir.mkdir(parents=True, exist_ok=True)
-    return {"managerId": manager_id, "taskGroup": task_group, "createdAt": now or _now_iso()}
+    meta = _ensure_group_meta(home, manager_id, task_group, now or _now_iso())
+    return {"managerId": manager_id, **meta}
 
 
 def _merge_manifest(existing: dict, requested: dict) -> None:
@@ -313,6 +328,7 @@ def create_task(
         )
     children["children"].extend(added)
     if not existing:
+        _ensure_group_meta(home, manager_id, task_group, when)
         _write_json(manifest_path, manifest)
     _write_json(children_json_path(home, manager_id, task_group, task_id), children)
     append_jsonl(
@@ -423,3 +439,194 @@ def append_directive(
     }
     append_jsonl(directives_jsonl_path(home, manager_id, task_group, task_id), row)
     return row
+
+
+def list_task_groups(home: Path, manager_id: str) -> list[dict]:
+    """태스크가 없는 그룹까지 포함해 그룹을 이름 순으로 돌려준다.
+
+    `group.json` 이 없는 기존 그룹은 소속 태스크 manifest 의 그룹 이름을, 태스크도 없으면
+    폴더 이름을 쓴다.
+    """
+    load_manager(home, manager_id)
+    base = task_groups_root(home, manager_id)
+    if not base.is_dir():
+        return []
+    items: list[dict] = []
+    for group_dir in sorted(path for path in base.iterdir() if path.is_dir()):
+        manifests = sorted(group_dir.glob("*/manifest.json"))
+        meta_path = group_dir / "group.json"
+        meta = _read_json(meta_path) if meta_path.is_file() else {}
+        name = str(meta.get("taskGroup") or "")
+        if not name and manifests:
+            name = str(_read_json(manifests[0]).get("taskGroup") or "")
+        items.append(
+            {
+                "taskGroup": name or group_dir.name,
+                "createdAt": str(meta.get("createdAt") or ""),
+                "taskCount": len(manifests),
+            }
+        )
+    return sorted(items, key=lambda item: item["taskGroup"])
+
+
+def _children_of_project(home: Path, manager_id: str, project_id: str) -> list[tuple[dict, list[str]]]:
+    """(task manifest, 그 task 에서 project_id 를 가리키는 하위 태스크 키) 목록."""
+    rows = []
+    for path in _task_manifest_paths(home, manager_id):
+        children = _read_json_default(path.parent / "children.json", {"children": []})
+        keys = [
+            str(child.get("taskKey"))
+            for child in children.get("children", [])
+            if isinstance(child, dict) and child.get("projectId") == project_id
+        ]
+        if keys:
+            rows.append((_read_json(path), keys))
+    return rows
+
+
+def unlink_project(
+    home: Path, manager_id: str, project_id: str, *, confirm: bool, now: str | None = None
+) -> dict:
+    """프로젝트 등록을 해제한다. 하위 태스크는 남기고, 등록 목록에 없다는 사실로 해제 상태를 표시한다.
+
+    `confirm` 이 거짓이면 대상만 돌려주고 아무것도 바꾸지 않는다.
+    """
+    load_manager(home, manager_id)
+    payload = _load_projects(home, manager_id)
+    entry = _project_entry(payload, project_id)
+    if entry is None:
+        raise ManagerError(f"unknown project membership: {project_id}")
+    affected = _children_of_project(home, manager_id, project_id)
+    result = {
+        "managerId": manager_id,
+        "projectId": project_id,
+        "projectRoot": str(entry.get("projectRoot") or ""),
+        "keptChildren": [key for _, keys in affected for key in keys],
+        "removed": confirm,
+    }
+    if not confirm:
+        return result
+    payload["projects"] = [item for item in payload["projects"] if item is not entry]
+    _write_json(projects_json_path(home, manager_id), payload)
+    when = now or _now_iso()
+    for manifest, keys in affected:
+        append_jsonl(
+            events_jsonl_path(home, manager_id, str(manifest["taskGroup"]), str(manifest["taskId"])),
+            {"event": "project-unlinked", "createdAt": when, "projectId": project_id, "taskKeys": keys},
+        )
+    return result
+
+
+def remove_child(
+    home: Path,
+    manager_id: str,
+    task_group: str,
+    task_id: str,
+    project_id: str,
+    *,
+    child_task_id: str | None = None,
+    confirm: bool,
+    now: str | None = None,
+) -> dict:
+    """하위 태스크 하나를 manager 에서 뺀다. 프로젝트의 `.okstra/` 는 건드리지 않는다."""
+    _read_json(task_manifest_path(home, manager_id, task_group, task_id))
+    payload = _load_children(home, manager_id, task_group, task_id)
+    child = _select_child_for_assignment(payload["children"], project_id, task_group, child_task_id)
+    task_key = str(child.get("taskKey") or "")
+    result = {"managerId": manager_id, "taskGroup": task_group, "taskId": task_id,
+              "taskKey": task_key, "removed": confirm}
+    if not confirm:
+        return result
+    payload["children"] = [item for item in payload["children"] if item is not child]
+    _write_json(children_json_path(home, manager_id, task_group, task_id), payload)
+    # 남은 형제의 context 에 지운 하위 태스크가 형제로 실리지 않게 스냅샷 행도 뺀다.
+    snapshot_path = snapshots_json_path(home, manager_id, task_group, task_id)
+    if snapshot_path.is_file():
+        snapshot = _read_json(snapshot_path)
+        snapshot["children"] = [
+            row for row in snapshot.get("children", []) if not isinstance(row, dict) or row.get("taskKey") != task_key
+        ]
+        _write_json(snapshot_path, snapshot)
+    child_context_path(
+        home, manager_id, task_group, task_id, project_id, str(child.get("taskId") or task_id)
+    ).unlink(missing_ok=True)
+    append_jsonl(
+        events_jsonl_path(home, manager_id, task_group, task_id),
+        {"event": "task-child-removed", "createdAt": now or _now_iso(), "taskKey": task_key},
+    )
+    return result
+
+
+def update_task(
+    home: Path,
+    manager_id: str,
+    task_group: str,
+    task_id: str,
+    *,
+    objective: str | None = None,
+    common_brief_path: str | None = None,
+    progress_mode: str | None = None,
+    now: str | None = None,
+) -> dict:
+    """manager task 의 objective·공통 브리프·진행 방식 중 넘긴 값만 바꾼다."""
+    manifest_path = task_manifest_path(home, manager_id, task_group, task_id)
+    manifest = _read_json(manifest_path)
+    requested = {"objective": objective, "commonBriefPath": common_brief_path, "progressMode": progress_mode}
+    requested = {key: value for key, value in requested.items() if value is not None}
+    if not requested:
+        raise ManagerError("task update needs at least one of --objective, --common-brief, --progress-mode")
+    if requested.get("progressMode") not in (None, "manual", "auto"):
+        raise ManagerError("progress-mode must be manual or auto")
+    changes = {
+        key: {"from": manifest.get(key), "to": value}
+        for key, value in requested.items()
+        if manifest.get(key) != value
+    }
+    for key, change in changes.items():
+        manifest[key] = change["to"]
+    if changes:
+        _write_json(manifest_path, manifest)
+        append_jsonl(
+            events_jsonl_path(home, manager_id, task_group, task_id),
+            {"event": "task-updated", "createdAt": now or _now_iso(), "changes": changes},
+        )
+    return {"manifest": manifest, "changedFields": sorted(changes)}
+
+
+def remove_task(
+    home: Path, manager_id: str, task_group: str, task_id: str, *, confirm: bool
+) -> dict:
+    """manager task 폴더를 지운다. 하위 프로젝트의 태스크와 브리프는 남는다."""
+    manifest = _read_json(task_manifest_path(home, manager_id, task_group, task_id))
+    root = task_manifest_path(home, manager_id, task_group, task_id).parent
+    children = _load_children(home, manager_id, task_group, task_id)["children"]
+    result = {
+        "managerId": manager_id,
+        "taskGroup": str(manifest.get("taskGroup") or task_group),
+        "taskId": str(manifest.get("taskId") or task_id),
+        "path": str(root),
+        "childCount": len(children),
+        "removed": confirm,
+    }
+    if confirm:
+        shutil.rmtree(root)
+    return result
+
+
+def remove_task_group(home: Path, manager_id: str, task_group: str, *, confirm: bool) -> dict:
+    """그룹 폴더와 그 안의 manager task 전부를 지운다."""
+    load_manager(home, manager_id)
+    root = task_group_root(home, manager_id, task_group)
+    if not root.is_dir():
+        raise ManagerError(f"unknown task group: {task_group}")
+    task_ids = [str(_read_json(path).get("taskId") or path.parent.name) for path in sorted(root.glob("*/manifest.json"))]
+    result = {
+        "managerId": manager_id,
+        "taskGroup": task_group,
+        "path": str(root),
+        "taskIds": task_ids,
+        "removed": confirm,
+    }
+    if confirm:
+        shutil.rmtree(root)
+    return result

package/runtime/python/okstra_ctl/manager_sync.py

@@ -109,7 +109,7 @@ def sync_task(home: Path, manager_id: str, task_group: str, task_id: str, *, now
             continue
         project = projects.get(str(child.get("projectId") or ""))
         if project is None:
-            rows.append({**child, "exists": False, "error": "unknown project membership"})
+            rows.append({**child, "exists": False, "error": "project unlinked from this manager; re-register it with `okstra manager new project`"})
             continue
         root = Path(str(project.get("projectRoot") or ""))
         if not root.is_dir():
@@ -160,6 +160,7 @@ def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> d
     children = _read_json_default(children_json_path(home, manager_id, task_group, task_id), {"children": []})
     snapshot = _read_json_default(snapshots_json_path(home, manager_id, task_group, task_id), {"children": []})
     by_key = {row.get("taskKey"): row for row in snapshot.get("children", []) if isinstance(row, dict)}
+    linked = _project_map(home, manager_id)
     rows = []
     summary = {"planned": 0, "missing": 0, "running": 0, "done": 0, "blocked": 0}
     for child in children.get("children", []):
@@ -168,6 +169,8 @@ def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> d
         snapshot_row = by_key.get(child.get("taskKey"))
         row = {**child, **(snapshot_row or {})}
         row["summaryBucket"] = "planned" if snapshot_row is None else summary_bucket(row)
+        # `remove project` 는 하위 태스크를 남긴다. 등록 목록에 없으면 해제된 프로젝트의 것이다.
+        row["projectLinked"] = str(child.get("projectId") or "") in linked
         summary[row["summaryBucket"]] += 1
         rows.append(row)
     return {"manifest": manifest, "summary": summary, "children": rows, "lastSnapshot": snapshot}

package/runtime/python/okstra_ctl/manager_view.py

@@ -95,7 +95,8 @@ def _child_rows(children: list[dict], roots: dict[str, str]) -> list[list[str]]:
         assignment = assignment or "; ".join(child.get("scope") or [])
         rows.append(
             [
-                f"<code>{_e(child.get('taskKey'))}</code>",
+                f"<code>{_e(child.get('taskKey'))}</code>"
+                + ("" if child.get("projectLinked", True) else " " + _chip("unlinked")),
                 _e(child.get("ticketId") or "-"),
                 _chip(str(child.get("summaryBucket") or "planned")),
                 _e(child.get("workStatus") or "-"),

package/runtime/python/okstra_ctl/model_discovery.py

@@ -73,6 +73,25 @@ def _codex_home() -> Path:
     return Path.home() / ".codex"
 
 
+@lru_cache(maxsize=1)
+def codex_cli_version(codex_bin: str = "codex") -> str:
+    """디스패치에 쓸 codex CLI 의 버전, 알 수 없으면 "".
+
+    `codex --version` 은 `codex-cli 0.155.1` 처럼 마지막 마디에 버전을 싣는다.
+    """
+    try:
+        proc = subprocess.run(
+            [codex_bin, "--version"],
+            capture_output=True, text=True, timeout=20,
+        )
+    except (FileNotFoundError, OSError, subprocess.SubprocessError):
+        return ""
+    if proc.returncode != 0:
+        return ""
+    parts = proc.stdout.split()
+    return parts[-1].strip() if parts else ""
+
+
 def codex_availability(codex_home: Path | None = None) -> tuple[str, ...]:
     """Model slugs the codex CLI last fetched from the provider, or ().
 
@@ -100,6 +119,17 @@ def codex_availability(codex_home: Path | None = None) -> tuple[str, ...]:
     models = payload.get("models") if isinstance(payload, dict) else None
     if not isinstance(models, list):
         return ()
+    # 이 캐시는 codex 홈 하나를 쓰는 모든 클라이언트가 공유한다 — CLI 뿐 아니라
+    # ChatGPT 데스크톱 앱과 VS Code 확장도 자기 번들 버전으로 덮어쓴다. 그런데
+    # 카탈로그는 클라이언트 버전마다 다르다: 실측 2026-09-23, 같은 계정에서
+    # 0.155.1 은 gpt-6-sol·gpt-6-luna 를 내놓고 0.154.0·0.153.4 는 내놓지 않으며,
+    # 세 버전이 10분 사이 번갈아 이 파일을 썼다. 다른 클라이언트가 쓴 목록은
+    # okstra 가 실행할 CLI 의 카탈로그에 대한 근거가 아니므로 판정을 끈다 —
+    # 탐색 실패와 같은 처리이고, 정말 없는 모델이면 CLI 자신이 거절한다.
+    writer = payload.get("client_version")
+    running = codex_cli_version()
+    if running and isinstance(writer, str) and writer.strip() and writer.strip() != running:
+        return ()
     out: list[str] = []
     for entry in models:
         slug = entry.get("slug") if isinstance(entry, dict) else None

package/runtime/python/okstra_ctl/model_io/lines.py

@@ -10,6 +10,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any, Mapping
 
+from okstra_project.phase_pointer import promote
+
 from ..fixed_text import line as _line, scalar as _value
 from ..json_boundary import JsonBoundaryError
 
@@ -19,6 +21,17 @@ def _mapping(payload: Mapping[str, Any], key: str) -> Mapping[str, Any]:
     return value if isinstance(value, Mapping) else {}
 
 
+def next_phase_pointer(payload: Mapping[str, Any]) -> Mapping[str, Any]:
+    """`nextRecommendedPhase` 를 포인터로 읽는다. 구형 문자열도 승격한다.
+
+    `_mapping` 으로 읽으면 구형 문자열 포인터가 빈 매핑이 되어 `Next phase: -`
+    로 사라진다(ADR-0004 의 승격 예외가 이 읽기 경로에는 없었다). 값이 아예
+    없으면 빈 매핑 그대로 둔다 — 없는 포인터를 `pending` 으로 지어내지 않는다.
+    """
+    value = payload.get("nextRecommendedPhase")
+    return {} if value is None else promote(value)
+
+
 def _project_policy_lines(project: Mapping[str, Any]) -> str:
     packs = project.get("reviewRulePacks")
     pack_lines = (
@@ -84,7 +97,7 @@ def _worker_prompt_lines(run: Mapping[str, Any]) -> str:
 
 
 def _next_phase_lines(workflow: Mapping[str, Any]) -> str:
-    pointer = _mapping(workflow, "nextRecommendedPhase")
+    pointer = next_phase_pointer(workflow)
     return (
         _line("Next phase", pointer.get("phase"))
         + _line("Next phase status", pointer.get("status"))

package/runtime/python/okstra_ctl/model_io/renderers.py

@@ -29,6 +29,7 @@ from .lines import (
     _mapping,
     _next_phase_lines,
     _project_policy_lines,
+    next_phase_pointer,
     _provider_models,
     _status_overview_text,
     _worker_assignment_lines,
@@ -84,7 +85,7 @@ def _overview_rows(
         latest_run = _latest_timeline_run(project_root, manifest_path)
         _, group, _ = parse_task_key(task_key)
         workflow = _mapping(manifest, "workflow")
-        next_phase = _mapping(workflow, "nextRecommendedPhase")
+        next_phase = next_phase_pointer(workflow)
         # task 단위 현재 사실은 task-manifest 가 권위다(validate-run 이 run 종료
         # 시 거기에 쓴다). timeline 의 마지막 run 은 task-manifest 에 그 필드가
         # 없을 때의 폴백이고, 그 값도 run-manifest 로 덮어쓴 현재 사실이다.
@@ -372,7 +373,7 @@ def render_recap_input(project_root: Path, task_ref: str) -> str:
     for transition in transitions if isinstance(transitions, list) else []:
         if not isinstance(transition, Mapping):
             continue
-        pointer = _mapping(transition, "nextRecommendedPhase")
+        pointer = next_phase_pointer(transition)
         blocks.extend((
             "\n## Transition\n\n",
             _line("Run timestamp", transition.get("runTimestamp")),
@@ -420,7 +421,7 @@ def render_group_recap_input(project_root: Path, task_group: str) -> str:
     for task in tasks if isinstance(tasks, list) else []:
         if not isinstance(task, Mapping):
             continue
-        pointer = _mapping(task, "nextRecommendedPhase")
+        pointer = next_phase_pointer(task)
         memory = _mapping(task, "memory")
         blocks.extend((
             "\n## Task\n\n",

package/runtime/python/okstra_ctl/models.py

@@ -35,7 +35,7 @@ IMPLEMENTATION_ROLES = frozenset({"executor", "verifier"})
 # Legacy role-keyed compatibility defaults. Canonical assignments resolve a
 # provider first and then use ProviderSpec.default_models for that role.
 ROLE_DEFAULTS = {
-    "lead": "opus", "claude": "opus", "codex": "gpt-5.6-sol",
+    "lead": "opus", "claude": "opus", "codex": "gpt-6-sol",
     "antigravity": "gemini-3.1-pro", "report-writer": "sonnet",
 }
 

package/runtime/python/okstra_ctl/next_phase.py

@@ -235,8 +235,9 @@ def _from_option_selection(report_data: Mapping[str, Any]) -> dict[str, str]:
         # release-handoff 는 `routingRecommendation`.
         return make(status=STATUS_BLOCKED, rationale=_selection_guidance(selection))
     if routing == "pending-direction-selection":
-        # 이 상태는 **성공**이다 — 비교가 끝났고, 방향은 계획 단계의 위저드가
-        # 고르게 한다(`selected_direction_pick`). 그러니 다음 phase 는 지금 바로
+        # 이 상태는 **성공**이다 — 비교가 끝났고, 방향은 HTML 열람본의
+        # `DIRECTION SELECTION` Export 가 고르며 계획 위저드의
+        # `selected_direction_pick` 은 그 답이 딸린 리포트를 고른다. 그러니 다음 phase 는 지금 바로
         # 시작할 수 있는 `implementation-planning` 이고 status 는 `ready` 다.
         # 종전에는 phase 없는 `pending` 이었다: task 선택 화면이 `next: --
         # (pending)` 을 찍어 목적지를 지웠고, task-type 화면은 추천 없이 방금
@@ -276,11 +277,20 @@ def _direction_selection_reason(selection: Mapping[str, Any]) -> str:
     recommended = _text(selection.get("recommendedOptionId"))
     head = f"비교가 끝났습니다. 후보 {listed} 중 하나를 방향으로 고르세요"
     head += f" (권장 `{recommended}`)." if recommended else "."
+    # 위저드의 `selected_direction_pick` 은 후보가 아니라 **리포트**를 고른다
+    # (`wizard/steps_plan.py` `_build_selected_direction_pick`). 방향은 그 리포트
+    # 옆 `user-responses/` 의 `DIRECTION SELECTION` 사이드카가 정한다
+    # (`implementation_direction.py` `_comparison_selection`). 종전 문장은
+    # "위저드에 후보가 선택지로 나온다" 고 해서 사이드카 없이 계획을 열게 했다.
     return (
-        f"{head} 고르는 자리는 계획 단계의 위저드입니다 — `/okstra-run` 으로 "
-        "`implementation-planning` 을 시작하면 이 후보들이 선택지로 나옵니다. "
-        "이 phase 를 다시 돌리지 마세요: 비교는 이미 끝났고, 재실행은 같은 "
-        "비교를 처음부터 다시 합니다."
+        f"{head} 고르는 자리는 이 리포트의 HTML 열람본입니다 — 방향 선택 칸에서 "
+        "후보를 고르고 Export 한 파일을 "
+        "`runs/implementation-option-selection/user-responses/"
+        "user-response-implementation-option-selection-<이 리포트 번호>.md` 로 "
+        "저장하세요. 그다음 `/okstra-run` 으로 `implementation-planning` 을 "
+        "시작하고 위저드의 방향 보고서 단계에서 이 리포트를 고르면 저장한 방향이 "
+        "계획에 전달됩니다. 이 phase 를 다시 돌리지 마세요: 비교는 이미 끝났고, "
+        "재실행은 같은 비교를 처음부터 다시 합니다."
     )
 
 

package/runtime/python/okstra_ctl/operation_invocation.py

@@ -0,0 +1,86 @@
+"""okstra-run 밖에서 도는 Okstra 소유 LLM 작업의 준비.
+
+작업 계약(`agents/operations/<id>.json`)이 직무와 워커 수를 소유하고, 역할은 그
+직무의 `roleId` 에서 파생된다. 기술 문서는 작업 이름만 전달한다 — 역할·공급자·
+모델을 기술이 조립하면 같은 역할이 호출 표면마다 다른 규칙으로 배정된다
+(ADR-0017).
+"""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from .contract_graph import (
+    ContractGraphError,
+    ContractGraphRoot,
+    ContractGraphValidator,
+    ContractSelection,
+)
+from .model_pool import ModelPool
+
+
+class OperationPreparationError(ValueError):
+    """작업을 디스패치 전에 준비할 수 없다. 메시지가 그 자리를 이름한다."""
+
+
+@dataclass(frozen=True)
+class OperationSlot:
+    """이 작업이 열 워커 한 칸. 모델은 칸마다 다르다."""
+
+    operation_id: str
+    duty_id: str
+    role_id: str
+    ordinal: int
+    model_ref: str
+    provider_id: str
+    display_name: str
+
+
+def resolve_operation_slots(
+    operation_id: str,
+    *,
+    contract_root: Path,
+    pool: ModelPool,
+) -> Sequence[OperationSlot]:
+    """작업 계약이 요구하는 칸과 각 칸의 모델.
+
+    모델은 런과 같은 기본값 사슬에서 고른다. 서로 다른 모델 참조를 요구한
+    수만큼 채우지 못하면 여기서 멈춘다 — 같은 모델을 반복하거나 워커 수를
+    줄이면 그 작업이 요구한 교차검증이 조용히 사라진다.
+    """
+    graph_root = ContractGraphRoot.from_base(contract_root)
+    try:
+        graph = ContractGraphValidator().validate(
+            graph_root, selected=ContractSelection(operation_id=operation_id)
+        )
+    except ContractGraphError as exc:
+        raise OperationPreparationError(str(exc)) from exc
+    operation = graph.operations.get(operation_id)
+    if operation is None:
+        known = ", ".join(sorted(graph.operations)) or "(none)"
+        raise OperationPreparationError(
+            f"unknown operation: {operation_id} (known: {known})"
+        )
+    duty_id = str(operation.payload["dutyId"])
+    count = int(operation.payload["count"])
+    role_id = graph.duties[duty_id].role_id
+
+    candidates = pool.default_candidates(role_id)
+    if len(candidates) < count:
+        raise OperationPreparationError(
+            f"operation {operation_id!r} requires {count} distinct models for role "
+            f"{role_id!r}, available {len(candidates)}"
+        )
+    slots = []
+    for ordinal, model in enumerate(candidates[:count], start=1):
+        slots.append(OperationSlot(
+            operation_id=operation_id,
+            duty_id=duty_id,
+            role_id=role_id,
+            ordinal=ordinal,
+            model_ref=str(model.model_ref),
+            provider_id=model.provider_id,
+            display_name=model.display_name,
+        ))
+    return tuple(slots)