okstra 0.121.1 → 0.123.0

package/runtime/python/okstra_ctl/render.py

@@ -1351,6 +1351,11 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
     }
     if ctx.get("FIX_CYCLE_ID"):
         payload["fixCycleId"] = ctx["FIX_CYCLE_ID"]
+    payload["reportContracts"] = (
+        ["implementation-design-prep-v1"]
+        if ctx.get("TASK_TYPE") == "implementation-planning"
+        else []
+    )
     _write_json(Path(run_manifest_path), payload)
 
 
@@ -1735,6 +1740,9 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     lead_contract_path = ctx.get("OKSTRA_LEAD_CONTRACT_PATH") or str(
         home_prompts / "lead" / "okstra-lead-contract.md"
     )
+    adapter_contract_path = ctx.get("OKSTRA_LEAD_ADAPTER_CONTRACT_PATH") or str(
+        home_prompts / _lead_info(ctx).adapter_contract_relative_path
+    )
     context_loader_path = ctx.get("OKSTRA_CONTEXT_LOADER_PATH") or str(
         home_prompts / "lead" / "context-loader.md"
     )
@@ -1756,7 +1764,10 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     okstra_runtime_resources_block = (
         "## Okstra Runtime Resources\n"
         "\n"
-        f"- Lead contract: `{lead_contract_path}`\n"
+        f"- Lifecycle core contract: `{lead_contract_path}`\n"
+        f"- Selected runtime adapter contract: `{adapter_contract_path}`\n"
+        "- Read the lifecycle core first, then the selected adapter. "
+        "Only the selected adapter may define host tool spelling.\n"
         f"- Context loader: `{context_loader_path}`\n"
         f"- Team contract: `{team_contract_path}`\n"
         f"- Convergence contract: `{convergence_path}`\n"
@@ -1822,193 +1833,97 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
         else "- `Antigravity worker` is not selected for this run, so no Antigravity attempt is required."
     )
 
-    # Teammate dispatch gate block: phase-conditional. CC v2.1.178 removed
-    # TeamCreate/TeamDelete + the Agent team_name param; every session owns one
-    # implicit team, so workers dispatch with Agent(name: ...) and no team_name.
-    # - release-handoff (and any other phase that renders with no workers
-    #   selected) is single-lead and dispatches no teammate at all. Emit a
-    #   short notice instead of the BLOCKING gate.
-    # - concurrent implementation runs only record an audit marker (each session
-    #   has its own implicit team, so there is no shared-team conflict).
-    # - All other phases keep the full teammate-dispatch contract.
     task_type = ctx.get("TASK_TYPE", "")
-    concurrent_stages = str(ctx.get("CONCURRENT_RUN_STAGES", "") or "").strip()
-    codex_dispatch_command = (
-        "okstra codex-dispatch "
-        f"--project-root {ctx.get('PROJECT_ROOT', '')} "
-        f"--run-manifest {ctx.get('RUN_MANIFEST_RELATIVE_PATH', '')}"
-    )
-    team_dispatch_command = (
-        "okstra team dispatch "
-        f"--project-root {ctx.get('PROJECT_ROOT', '')} "
-        f"--run-manifest {ctx.get('RUN_MANIFEST_RELATIVE_PATH', '')}"
-    )
-    team_await_command = (
-        "okstra team await "
-        f"--project-root {ctx.get('PROJECT_ROOT', '')} "
-        f"--run-manifest {ctx.get('RUN_MANIFEST_RELATIVE_PATH', '')}"
-    )
-    if task_type == "release-handoff" or not selected:
-        team_creation_gate_block = (
-            "## Single-Lead Phase (no team creation)\n"
-            "\n"
-            "This run is single-lead. There is no worker roster, no\n"
-            "`TeamCreate` call, no `Agent(...)` worker dispatch, and no\n"
-            f"convergence loop. The {lead_role} performs every step inline\n"
-            "(reading inputs, drafting commit / PR text when applicable,\n"
-            "asking the user, running git / gh, and writing the final\n"
-            "report). Do NOT call `TeamCreate` or dispatch any sub-agent\n"
-            "from this run — that would be a contract violation."
-        )
-    elif lead_runtime == "codex":
-        team_creation_gate_block = (
-            "## Codex Dispatch Gate (BLOCKING)\n"
-            "\n"
-            "This run was prepared for `leadRuntime=codex`. Do NOT call\n"
-            "`TeamCreate`, do NOT call Claude Code `Agent(...)`, and do NOT\n"
-            "invoke Claude slash skills. Codex dispatch is artifact-first and\n"
-            "uses the prepared run manifest plus CLI-backed worker wrappers.\n"
-            "\n"
-            "Required actions, in order:\n"
-            "\n"
-            "1. Inspect the run manifest and team-state paths listed below.\n"
-            "2. Emit `PROGRESS: phase-3-team-create skipped (codex-dispatch)`;\n"
-            "   there is no Claude Teams surface in this adapter.\n"
-            "3. Plan worker execution with:\n"
-            f"   `{codex_dispatch_command} --dry-run`\n"
-            "4. Dispatch supported Codex-side workers with:\n"
-            f"   `{codex_dispatch_command}`\n"
-            "   When `--workers` is omitted, unsupported roster entries such as\n"
-            "   `claude` are skipped with explicit `not-run` reasons.\n"
-            "5. Run `report-writer` only with explicit opt-in:\n"
-            f"   `{codex_dispatch_command} --enable-codex-report-writer --report-writer-codex-model <model>`\n"
-            "\n"
-            "`okstra codex-dispatch` records `team-state.dispatchMode`, writes\n"
-            "worker prompt histories when missing, persists worker results, and\n"
-            "runs post-report validation for the Codex report-writer path."
-        )
-    elif lead_runtime == "external":
-        team_creation_gate_block = (
-            "## Tmux Worker Dispatch Gate (BLOCKING)\n"
-            "\n"
-            "This run was prepared for `leadRuntime=external`. Do NOT call "
-            "`TeamCreate`, do NOT call Claude Code `Agent(...)`, and do NOT call "
-            "`okstra codex-dispatch`. This adapter dispatches workers through "
-            "okstra-owned tmux panes.\n"
-            "\n"
-            "Required actions, in order:\n"
-            "1. Inspect the run manifest and team-state paths listed below.\n"
-            "2. Emit `PROGRESS: phase-3-team-create skipped (tmux-pane)`; there is no Claude Teams surface in this adapter.\n"
-            "3. Plan worker execution with:\n"
-            f"   `{team_dispatch_command} --dry-run`\n"
-            "4. Dispatch workers with:\n"
-            f"   `{team_dispatch_command}`\n"
-            "5. Arm one background wait using this harness's async shell primitive:\n"
-            f"   `{team_await_command}`\n"
-            "6. On wake, read team-state. Worker completion is valid only from "
-            "`workerDispatches[]` plus result files; pane creation alone is not completion."
-        )
-    elif task_type == "implementation" and concurrent_stages:
-        team_creation_gate_block = (
-            "## Concurrent-run marker (BLOCKING)\n"
-            "\n"
-            "A concurrent implementation run of the same task-key holds stage(s)\n"
-            f"`{concurrent_stages}` right now. Each session owns its own implicit\n"
-            "team (`session-<leadSessionId-prefix>`), so concurrent same-task runs do\n"
-            "not share team state — this run dispatches normally and only records the\n"
-            "concurrent context for the audit trail.\n"
-            "\n"
-            "Required actions, in order:\n"
-            "\n"
-            "1. Before any dispatch, record in team-state:\n"
-            '   `teamCreate: { attempted: false, status: "skipped",'
-            f' reason: "concurrent-run", concurrentStages: [{concurrent_stages}] }}`.\n'
-            "2. Immediately after recording it, emit the checkpoint line\n"
-            "   `PROGRESS: phase-3-team-create skipped (concurrent-run)` — the\n"
-            "   phase-3 checkpoint is required and the session-conformance validator\n"
-            "   fails the run without it.\n"
-            "3. Dispatch every worker with `Agent(name: ..., run_in_background: true)`\n"
-            "   and NO `team_name`; teammates join this session's implicit team and\n"
-            "   render as split-panes when `$TMUX` is set."
-        )
-    else:
+    adapter_setup_facts: list[str] = []
+    if lead_runtime == "claude-code":
         base_name = f'okstra-{ctx.get("TASK_KEY", "")}'
         impl_stage = str(ctx.get("EFFECTIVE_STAGES", "") or "").strip()
         fv_stage = str(ctx.get("RUN_STAGE", "") or "").strip()
         stage_suffix = ""
         if task_type == "implementation" and impl_stage:
-            # stage 격리 run 은 stage 별 team — 같은 task 의 다른 stage 가 남긴
-            # team 과 이름이 충돌하지 않는다(worktree branch `-s<N>` 접미사와 동형).
             stage_suffix = f"-s{impl_stage}"
         elif task_type == "final-verification" and fv_stage:
-            # 단일-stage final-verification 도 stage 별 team. `-fv-` 를 끼워
-            # 같은 stage 의 implementation team(`-s<N>`)과도 구분한다 — 둘은
-            # 동시에 살아 있을 수 있다. whole-task 검증(RUN_STAGE 빈 값)은
-            # 기본 이름 유지.
             stage_suffix = f"-fv-s{fv_stage}"
-        team_name = sanitize_team_name(base_name, stage_suffix)
+        adapter_setup_facts.append(
+            f"- Adapter audit label: `{sanitize_team_name(base_name, stage_suffix)}`"
+        )
+    concurrent_stages = str(ctx.get("CONCURRENT_RUN_STAGES", "") or "").strip()
+    if concurrent_stages:
+        adapter_setup_facts.append(
+            f"- Prepare-recorded concurrent stages: `{concurrent_stages}`"
+        )
+    adapter_setup_block = (
+        "\n".join(adapter_setup_facts)
+        if adapter_setup_facts
+        else "- Adapter setup facts: none"
+    )
+
+    if task_type == "release-handoff" or not selected:
         team_creation_gate_block = (
-            "## Teammate Dispatch Gate (BLOCKING)\n"
-            "\n"
-            "Before any `Agent` dispatch for workers, you MUST perform Phase 3 of the\n"
-            f'okstra lead contract (`{lead_contract_path}` → "Phase 3 — Teammate setup").\n'
+            "## Single-Lead Phase (no worker dispatch)\n"
             "\n"
-            "Claude Code v2.1.178 removed the `TeamCreate` / `TeamDelete` tools and the\n"
-            "`Agent(...)` `team_name` parameter. With `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`\n"
-            "(seeded by `okstra install`) this session already owns one implicit team;\n"
-            "workers spawned with `Agent(name: ...)` auto-join it. Do NOT probe or call\n"
-            "`TeamCreate` — its absence is the normal state on every current Claude Code,\n"
-            "not an 'Agent Teams unavailable' signal, and never a reason to degrade the run.\n"
-            "\n"
-            "Required actions, in order, regardless of how many workers are selected\n"
-            "for this run (roster comes from `resultContract.requiredWorkerRoles` in\n"
-            "`task-manifest.json` — it may be 1, 2, 3, or more workers):\n"
+            "This run has no worker roster or convergence loop. The lead performs "
+            "the phase inline and follows the selected adapter only for user prompts, "
+            "artifact operations, usage collection, and cleanup."
+        )
+    else:
+        team_creation_gate_block = (
+            "## Runtime Adapter Dispatch Gate (BLOCKING)\n"
             "\n"
-            f"1. Read the team-contract resource (`{team_contract_path}`) and verify the selected worker\n"
-            "   roster against `task-manifest.json`'s `resultContract.requiredWorkerRoles`.\n"
-            "2. Record team-state BEFORE any dispatch:\n"
-            f'   `teamName: "{team_name}"` (audit/display label only) AND\n'
-            '   `teamCreate: { attempted: false, status: "implicit",'
-            " splitPane: <true if $TMUX set, else false> }`.\n"
-            '3. Dispatch every worker with `Agent(name: "<role>-worker",'
-            " run_in_background: true)` and NO `team_name`. Split-pane teammates appear\n"
-            "   automatically when `$TMUX` is set (`teammateMode: auto`); when it is\n"
-            "   unset they run in-process — both are normal, not a degraded run."
+            f"- Selected lead runtime: `{lead_runtime}`\n"
+            f"- Selected adapter contract: `{adapter_contract_path}`\n"
+            "- Read that adapter before Phase 3. Execute `prompt_user`, "
+            "`dispatch_worker`, `await_workers`, `redispatch_worker`, "
+            "`shutdown_workers`, `record_lead_event`, and `collect_usage` only "
+            "through its mapping.\n"
+            "- Do not call a primitive documented by an unselected adapter.\n"
+            "- Record the adapter-required Phase 3 state and emit the canonical "
+            "`PROGRESS: phase-3-team-create ...` checkpoint before dispatch.\n"
+            f"{adapter_setup_block}\n"
+            "- The run manifest is authoritative for concurrent-run metadata, "
+            "dispatch backend, and artifact paths."
         )
 
+    lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
+    lead_bootstrap_instruction = (
+        f"Read the Lifecycle core contract at `{lead_contract_path}`, then read the "
+        f"selected runtime adapter at `{adapter_contract_path}`. Read the manifests "
+        "below for all task metadata, paths, model assignments, and worker roster. "
+        "Execute `write_artifact`, `dispatch_worker`, and `await_workers` only through "
+        "the selected adapter's mapping. Follow the lifecycle core's lazy-read rules "
+        "for support resources; do not invoke hidden/internal skills."
+    )
+    worker_preamble_path = ctx.get(
+        "WORKER_PROMPT_PREAMBLE_PATH",
+        str(okstra_home() / "templates" / "worker-prompt-preamble.md"),
+    )
+    worker_dispatch_guidance = (
+        "## Worker Dispatch Contract\n"
+        "\n"
+        "- Worker prompt paths in `task-manifest.json` are assigned prompt-history "
+        "locations, not pre-rendered completion markers. An absent file means its "
+        "dispatch history has not been materialized yet.\n"
+        "- Construct each required worker prompt and follow the lifecycle core plus "
+        "selected adapter to persist its assigned history through `write_artifact` "
+        "and start it through `dispatch_worker`. Existing-history handling must stay "
+        "idempotent under those contracts.\n"
+        "- Use `await_workers` through the selected adapter and confirm terminal state "
+        "plus every required Result Path. File presence alone is never a signal to "
+        "skip; worker selection and skipped status come from `team-state`.\n"
+        "- Every worker prompt must include the anchor header "
+        f"`**Worker Preamble Path:** {worker_preamble_path}`. That file is the canonical "
+        "source for Required Reading, Error Reporting, and Output sections; do not "
+        "re-inline those blocks into worker prompt bodies."
+    )
+
     if lead_runtime == "external":
-        lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
-        lead_bootstrap_instruction = (
-            "Read the manifests below for all task metadata, paths, model "
-            "assignments, and worker roster. Use the tmux worker dispatch gate "
-            "in this prompt; do not invoke Claude Code skills."
-        )
         lead_session_block = (
             "## Session\n"
             "\n"
             "- Lead runtime: `external`\n"
             "- Lead session accounting: artifact-only; this harness does not expose Claude Code jsonl session IDs."
         )
-        worker_dispatch_guidance = (
-            "## Tmux Worker Dispatch\n"
-            "\n"
-            "- Worker prompt paths in `task-manifest.json` are assigned history "
-            "locations. `okstra team dispatch` materializes missing prompt files "
-            "from the run manifest and active-run-context; existing prompt files "
-            "are never overwritten.\n"
-            "- Do not call `TeamCreate`, `Agent(...)`, or `okstra codex-dispatch`. "
-            "Use `okstra team dispatch` and `okstra team await` from the gate "
-            "above for worker execution.\n"
-            "- File presence is not a signal to skip. Worker selection and skipped "
-            "statuses come from `team-state`, never from the prompts directory."
-        )
     elif lead_runtime == "codex":
-        lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
-        lead_bootstrap_instruction = (
-            "Read the manifests below for all task metadata, paths, model "
-            "assignments, and worker roster. Use the Codex dispatch gate in this "
-            "prompt; do not invoke Claude Code skills."
-        )
         lead_session_block = (
             "## Session\n"
             "\n"
@@ -2016,41 +1931,13 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
             "- Codex run resume is artifact/checkpoint based; `okstra codex-run` "
             "does not create a Claude session id."
         )
-        worker_dispatch_guidance = (
-            "## Codex Worker Dispatch\n"
-            "\n"
-            "- Worker prompt paths in `task-manifest.json` are assigned history "
-            "locations. `okstra codex-dispatch` materializes missing prompt files "
-            "from the run manifest and active-run-context; existing prompt files "
-            "are never overwritten.\n"
-            "- Do not call `TeamCreate` or `Agent(...)`. Use the command in the "
-            "Codex Dispatch Gate above for worker execution.\n"
-            "- File presence is not a signal to skip. Worker selection and skipped "
-            "statuses come from `team-state`, never from the prompts directory."
-        )
     else:
-        lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
-        lead_bootstrap_instruction = (
-            f"Read the Okstra lead contract at `{lead_contract_path}` now, then read "
-            "the manifests below for all task metadata, paths, model assignments, and "
-            "worker roster. Follow the contract's lazy-read rules for support resources; "
-            "do not invoke hidden/internal skills."
-        )
         lead_session_block = (
             "## Session\n"
             "\n"
             f"- Session ID: `{ctx.get('CLAUDE_SESSION_ID', '')}`\n"
             f"- Resume: `{ctx.get('CLAUDE_RESUME_COMMAND_RELATIVE_PATH', '')}`"
         )
-        worker_dispatch_guidance = (
-            "## Worker Prompt Files (not pre-rendered)\n"
-            "\n"
-            "- The `runs/<phase>/prompts/<worker>-worker-prompt-*.md` files referenced in `task-manifest.json → artifacts.workerPromptPathByWorkerId` are **NOT** rendered by the okstra runtime. Those paths are the *assigned* locations where the prompt history MUST be written at dispatch time.\n"
-            "- Therefore: at the start of every phase the prompts/ directory is normally empty (or contains only previously-dispatched workers' files). This is expected. Do NOT narrate it as \"missing\", \"누락\", or \"not yet rendered\" — it just means dispatch has not happened yet.\n"
-            "- Before dispatching any required worker, **you (the lead) construct the worker prompt and persist it to the assigned absolute path using `Write`** (per `team-contract` rule 6). Only after persisting do you call the worker subagent (Agent tool / Codex / Antigravity wrapper). The wrapper subagents will also re-write the same file on their end; the double-write is intentional and idempotent.\n"
-            "- Do not \"check if the file exists and skip dispatch\" — file presence is not a signal to skip. Worker selection and skipping rules come from team-state, never from prompts/ directory contents.\n"
-            f"- **Worker Preamble Path (single anchor — replaces inlined `[Required reading]` and `[Error reporting]` blocks).** Every worker prompt you construct MUST include the anchor header `**Worker Preamble Path:** {ctx.get('WORKER_PROMPT_PREAMBLE_PATH', str(okstra_home() / 'templates' / 'worker-prompt-preamble.md'))}`. The file at that path is the canonical SSOT for Required Reading + Error Reporting + Output sections; workers Read it end-to-end before producing output. Do NOT re-inline those blocks into worker prompt bodies — that is the legacy ~80-line dispatch boilerplate that this anchor is designed to replace."
-        )
 
     # Compute results (deterministic from ctx, 덮어쓰기)
     ctx["LEAD_INTRO_LINE"] = lead_intro_line

package/runtime/python/okstra_ctl/report_views.py

@@ -597,24 +597,32 @@ _ENUM_CUE_WORDS: tuple[str, ...] = (
 
 def _parse_enum_options(statement: str) -> list[tuple[str, str]]:
     """Return ``[(letter, text)]`` pairs if ``statement`` looks like a
-    ``(a) X (b) Y (c) Z`` enumeration, else ``[]``. Stops at the first
-    recommendation cue (``권장``/``추천``/``사유``/``근거``) so the
+    ``(a) X (b) Y (c) Z`` enumeration, else ``[]``. The sequence may start
+    at any letter — a statement enum starts at ``(a)``, while the
+    ``Alternatives`` cell of the Expected-form contract starts at ``(b)``
+    (the recommended answer is ``(a)``) — so parsing keys off the first
+    ``(letter)`` marker found and walks the sequence from there. Stops at
+    the first recommendation cue (``권장``/``추천``/``사유``/``근거``) so the
     "(c) — recommended because ..." tail doesn't leak into the last
     option's text. Requires ≥ 2 options to trigger select rendering.
     """
     if not statement:
         return []
+    first = re.search(r"\(([a-z])\) ", statement)
+    if not first:
+        return []
+    letters = [chr(c) for c in range(ord(first.group(1)), ord("z") + 1)]
     out: list[tuple[str, str]] = []
     cursor = 0
-    for i, letter in enumerate(_ENUM_LETTERS):
+    for i, letter in enumerate(letters):
         anchor = f"({letter}) "
         idx = statement.find(anchor, cursor)
         if idx < 0:
             break
         start = idx + len(anchor)
         end_candidates: list[int] = []
-        if i + 1 < len(_ENUM_LETTERS):
-            n_idx = statement.find(f"({_ENUM_LETTERS[i + 1]}) ", start)
+        if i + 1 < len(letters):
+            n_idx = statement.find(f"({letters[i + 1]}) ", start)
             if n_idx >= 0:
                 end_candidates.append(n_idx)
         for cue in _ENUM_CUE_WORDS:
@@ -643,6 +651,13 @@ def _lettered_option(letter: str, text: str) -> str:
     return f"({letter}) {text}"
 
 
+def _strip_leading_letter_label(text: str) -> str:
+    """Drop a leading ``(a)`` / ``(b)`` … contract label so the caller can
+    re-letter the option exactly once (the contract labels the recommended
+    answer `(a)` and alternatives from `(b)`)."""
+    return re.sub(r"^\([a-z]\)\s*", "", text)
+
+
 def _parse_expected_form_options(expected_form: str) -> list[tuple[str, str]]:
     """Parse the ``Expected form`` contract format
     (``Recommended: <answer> — <rationale>; Alternatives: <options>``,
@@ -662,7 +677,7 @@ def _parse_expected_form_options(expected_form: str) -> list[tuple[str, str]]:
         alt_body = rec_body[alt_idx + len(_ALTERNATIVES_CUE):]
         rec_body = rec_body[:alt_idx]
     # The rationale follows " — "; the option keeps only the answer part.
-    answer = rec_body.split(" — ", 1)[0].strip(" .,;—-")
+    answer = _strip_leading_letter_label(rec_body.split(" — ", 1)[0].strip(" .,;—-"))
     options: list[tuple[str, str]] = []
     next_letter_idx = 0
     if answer:
@@ -678,7 +693,7 @@ def _parse_expected_form_options(expected_form: str) -> list[tuple[str, str]]:
             options.append((letter, _lettered_option(letter, text)))
             next_letter_idx += 1
     else:
-        alt_text = alt_body.strip(" .,;—-")
+        alt_text = _strip_leading_letter_label(alt_body.strip(" .,;—-"))
         if alt_text and next_letter_idx < len(_ENUM_LETTERS):
             letter = _ENUM_LETTERS[next_letter_idx]
             options.append((letter, _lettered_option(letter, alt_text)))

package/runtime/python/okstra_ctl/run.py

@@ -46,6 +46,7 @@ from .final_report_schema import load_schema
 from .final_report_paths import final_report_data_path as _final_report_data_path
 from .lead_events import LeadEvent, append_lead_event
 from .lead_runtime import ALLOWED_LEAD_RUNTIMES
+from .model_discovery import normalize_execution_for_dispatch
 from .models import ModelAssignment, default_model, resolve_model_metadata
 from .schema_excerpt import build_schema_excerpt
 from .path_resolve import relative_to_project_root, resolve_user_file
@@ -1412,6 +1413,27 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
     )
 
 
+def _normalized_execution(meta: ModelAssignment, provider: str, role: str) -> str:
+    """Route a role's catalog execution value through the CLI-identity normalizer
+    so the manifest carries the dispatch-correct spelling. SSOT for the mapping
+    lives in model_discovery; this is only the run.py call seam."""
+    return normalize_execution_for_dispatch(
+        provider=provider, execution=meta.execution, display=meta.display, role=role,
+    )
+
+
+def _worker_execution_value(
+    meta: ModelAssignment, provider: str, role: str, workers: list[str],
+) -> str:
+    """Normalize a worker role's execution value only when that provider's
+    worker is in the resolved roster; otherwise return the raw catalog value.
+    A worker that will not be dispatched must not probe its CLI or hard-fail
+    the whole prep (the CLI-identity check belongs only to workers that run)."""
+    if provider in workers:
+        return _normalized_execution(meta, provider=provider, role=role)
+    return meta.execution
+
+
 StageRunClaim = _implementation_stage.StageRunClaim
 
 
@@ -1577,7 +1599,9 @@ def _write_instruction_set_sources(
     instruction_set = Path(ctx["INSTRUCTION_SET_PATH"])
     instruction_set.mkdir(parents=True, exist_ok=True)
     profile_rendered = profile_content
-    for key in (
+    if inp.task_type == "implementation":
+        profile_rendered += "\n\n{{DESIGN_PREP_CONTEXT}}"
+    profile_tokens = (
         "EXECUTOR_PROVIDER",
         "EXECUTOR_DISPLAY_NAME",
         "EXECUTOR_WORKER_AGENT",
@@ -1588,10 +1612,28 @@ def _write_instruction_set_sources(
         "EXECUTOR_WORKTREE_BASE_REF",
         "EXECUTOR_WORKTREE_STATUS",
         "EXECUTOR_WORKTREE_NOTE",
+        "DESIGN_PREP_CONTEXT",
         "PHASE_FORBIDDEN_ACTIONS",
-    ):
+    )
+    for key in profile_tokens:
         profile_rendered = profile_rendered.replace("{{" + key + "}}", ctx.get(key, ""))
     (instruction_set / "analysis-profile.md").write_text(profile_rendered, encoding="utf-8")
+    if inp.task_type == "implementation":
+        executor_source = (
+            Path(ctx["WORKSPACE_ROOT"])
+            / "prompts"
+            / "profiles"
+            / "_implementation-executor.md"
+        )
+        executor_rendered = executor_source.read_text(encoding="utf-8")
+        for key in profile_tokens:
+            executor_rendered = executor_rendered.replace(
+                "{{" + key + "}}", ctx.get(key, "")
+            )
+        (instruction_set / "implementation-executor.md").write_text(
+            executor_rendered,
+            encoding="utf-8",
+        )
     (instruction_set / "analysis-material.md").write_text(review_material, encoding="utf-8")
     shutil.copyfile(inp.brief_path, instruction_set / "task-brief.md")
     if inp.clarification_response_path:
@@ -2058,16 +2100,22 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "CLAUDE_WORKER_MODEL": cw.display,
         "CLAUDE_WORKER_MODEL_EXECUTION_VALUE": cw.execution,
         "CODEX_WORKER_MODEL": co.display,
-        "CODEX_WORKER_MODEL_EXECUTION_VALUE": co.execution,
+        "CODEX_WORKER_MODEL_EXECUTION_VALUE": _worker_execution_value(
+            co, "codex", "worker", workers,
+        ),
         "ANTIGRAVITY_WORKER_MODEL": ge.display,
-        "ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE": ge.execution,
+        "ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE": _worker_execution_value(
+            ge, "antigravity", "worker", workers,
+        ),
         "REPORT_WRITER_MODEL": rw.display,
         "REPORT_WRITER_MODEL_EXECUTION_VALUE": rw.execution,
         "EXECUTOR_PROVIDER": executor_provider,
         "EXECUTOR_DISPLAY_NAME": executor_display_name,
         "EXECUTOR_WORKER_AGENT": executor_worker_agent,
         "EXECUTOR_MODEL_DISPLAY": executor_model_meta.display,
-        "EXECUTOR_MODEL_EXECUTION_VALUE": executor_model_meta.execution,
+        "EXECUTOR_MODEL_EXECUTION_VALUE": _normalized_execution(
+            executor_model_meta, provider=executor_provider, role="executor",
+        ),
         "CRITIC_CHOICE": critic_choice,
         "RELATED_TASKS_JSON": related_tasks_json_str,
         "RELATED_TASKS_BULLETS": bullets,

package/runtime/python/okstra_ctl/team_reconcile.py

@@ -15,7 +15,9 @@ recorded pane — those are left for graceful shutdown.
 CC v2.1.178 removed ``TeamDelete``: the implicit team ends with the session and
 run-end teardown only dismisses teammates via ``shutdown_request``. Reconcile
 keeps the roster honest so a dismissed-but-dead member does not linger as a
-live pill — see okstra-lead-contract.md "Run-scoped pane & teammate lifecycle".
+live pill — see okstra-lead-contract.md "Run-scoped worker-resource lifecycle"
+for neutral cleanup ownership and the selected Claude adapter's
+"Run-scoped resource lifecycle" for this provider-specific reconciliation.
 
 Roster resolution (``--project-root``) exists because ``team-state.lead.sessionId``
 is a phase-3 snapshot: Claude Code re-issues the session id across resume /

package/runtime/python/okstra_ctl/user_response.py

@@ -26,6 +26,7 @@ from okstra_ctl.clarification_items import (
     parse_clarification_rows,
     scan_approval_gate,
     section_1_present_but_unparsed,
+    _section_1_slice,
 )
 
 _APPROVAL_HEADING_RE = re.compile(r"^## APPROVAL\s*$", re.MULTILINE)
@@ -146,8 +147,14 @@ def list_awaiting_tasks(home: Path, project_id: str, limit: int) -> list[dict]:
     return out[:limit] if limit > 0 else out
 
 
-_SECTION_REF_RE = re.compile(r"§[\d.]+|C-\d+|[\w./-]+\.\w+:\d+")
+# ID tokens are the report body's own cross-reference labels (RB-002, FU-001,
+# O-002, C-017 …) — always uppercase-led so `gpt-5` and lowercase slugs don't
+# match. `§x.y` and `path.ext:line` are the other two ref shapes.
+_SECTION_REF_RE = re.compile(r"§[\d.]+|[A-Z]{1,4}-\d+|[\w./-]+\.\w+:\d+")
+_ID_TOKEN_RE = re.compile(r"^[A-Z]{1,4}-\d+$")
 _ALTERNATIVES_CUE = "Alternatives:"
+_DEFINITION_SNIPPET_CAP = 200
+_SNIPPET_NOISE_RE = re.compile(r'<a id="[^"]*"></a>|`|\*\*')
 
 
 def _alternatives_from_expected(expected_form: str) -> list[str]:
@@ -159,6 +166,63 @@ def _alternatives_from_expected(expected_form: str) -> list[str]:
     return [p.strip(" .,;—-") for p in parts if p.strip(" .,;—-")]
 
 
+def _clean_snippet(line: str) -> str:
+    s = _SNIPPET_NOISE_RE.sub("", line).strip()
+    s = re.sub(r"^[-*+]\s+|^\d+\.\s+", "", s)  # drop a leading list marker
+    s = re.sub(r"\s*\|\s*", " | ", s).strip(" |")
+    s = re.sub(r"\s+", " ", s)
+    if len(s) > _DEFINITION_SNIPPET_CAP:
+        s = s[:_DEFINITION_SNIPPET_CAP].rstrip() + "…"
+    return s
+
+
+def _resolve_id_token(report_text: str, token: str, s1_slice: str | None) -> str | None:
+    """Find where an internal report token (RB-002, FU-001, …) is defined.
+
+    Prefer a body line where the token is followed by a `:`/`—`/`-`/`)`
+    separator (its definition), else the first body occurrence. §1 rows are
+    skipped so the clarification statement being explained is never returned
+    as its own definition."""
+    definition_re = re.compile(rf"{re.escape(token)}\**\s*[)\]]?\s*[:—–-]")
+    fallback: str | None = None
+    for line in report_text.splitlines():
+        if token not in line:
+            continue
+        stripped = line.strip()
+        if s1_slice is not None and stripped and stripped in s1_slice:
+            continue
+        if definition_re.search(stripped):
+            return _clean_snippet(stripped)
+        if fallback is None:
+            fallback = _clean_snippet(stripped)
+    return fallback
+
+
+def _resolve_section_ref(report_text: str, ref: str) -> str | None:
+    num = ref.lstrip("§")
+    heading_re = re.compile(rf"^#{{1,6}}\s+{re.escape(num)}(?=[.\s]).*$", re.MULTILINE)
+    m = heading_re.search(report_text)
+    return _clean_snippet(m.group(0).lstrip("# ").strip()) if m else None
+
+
+def resolve_refs(report_text: str, refs: list[str]) -> list[dict]:
+    """Resolve each context ref to its plain-text definition from the report
+    body, or None when the report text alone cannot resolve it (a `path:line`
+    pointer). The deterministic lookup the skill uses to rewrite each
+    clarification question in self-contained plain language."""
+    s1_slice = _section_1_slice(report_text)
+    resolved: list[dict] = []
+    for ref in refs:
+        if ref.startswith("§"):
+            definition = _resolve_section_ref(report_text, ref)
+        elif _ID_TOKEN_RE.match(ref):
+            definition = _resolve_id_token(report_text, ref, s1_slice)
+        else:
+            definition = None
+        resolved.append({"ref": ref, "definition": definition})
+    return resolved
+
+
 def show_open_rows(report_path: Path) -> dict:
     text = report_path.read_text(encoding="utf-8")
     rows = []
@@ -172,7 +236,8 @@ def show_open_rows(report_path: Path) -> dict:
                      "status": it.status, "statement": statement,
                      "recommended": expected,  # raw cell keeps answer + rationale
                      "alternatives": _alternatives_from_expected(expected),
-                     "contextRefs": refs})
+                     "contextRefs": refs,
+                     "resolvedRefs": resolve_refs(text, refs)})
     return {"reportPath": str(report_path), "rows": rows}