okstra 0.163.2 → 0.165.0

package/runtime/python/okstra_ctl/report_views.py

@@ -1050,11 +1050,16 @@ class UserResponseEntry:
 
 
 @dataclass(frozen=True)
-class UserResponseApproval:
-    """HTML Plan Approval 위젯의 Export 결과. ``implementation_option`` 이 빈
-    문자열이면 라인을 생략한다 (소비 측은 Recommended Option 폴백)."""
-    approved: bool
+class UserPlanDecision:
+    """HTML 계획 결정 위젯의 Export 결과.
+
+    ``status`` 가 승인이 아니면 ``reason`` 이 필수다 — 사유 없는 반려는 다음
+    run 이 무엇을 고쳐야 하는지 알 수 없어 되돌아올 수밖에 없다.
+    ``implementation_option`` 이 빈 문자열이면 라인을 생략한다 (소비 측은
+    Recommended Option 폴백)."""
+    status: str
     implementation_option: str = ""
+    reason: str = ""
 
 
 @dataclass(frozen=True)
@@ -1072,6 +1077,13 @@ _ANALYSIS_REVIEW_STATUSES = frozenset({
     "rejected",
 })
 
+PLAN_DECISION_APPROVED = "approved"
+_PLAN_DECISION_STATUSES = frozenset({
+    PLAN_DECISION_APPROVED,
+    "revision-requested",
+    "rejected",
+})
+
 
 def _quoted_sidecar_field(label: str, value: str) -> str:
     cleaned = value.strip()
@@ -1100,12 +1112,25 @@ def _serialize_analysis_review(review: UserResponseAnalysisReview) -> str:
     )
 
 
+def _serialize_plan_decision(decision: UserPlanDecision) -> str:
+    if decision.status not in _PLAN_DECISION_STATUSES:
+        raise ValueError(f"invalid PLAN DECISION status: {decision.status}")
+    if decision.status != PLAN_DECISION_APPROVED and not decision.reason.strip():
+        raise ValueError(f"PLAN DECISION {decision.status} requires a Reason")
+    chunk = f"\n## PLAN DECISION\n- Status: {decision.status}\n"
+    if decision.implementation_option:
+        chunk += f"- Implementation-Option: {decision.implementation_option.strip()}\n"
+    if decision.reason.strip():
+        chunk += _quoted_sidecar_field("Reason", decision.reason)
+    return chunk
+
+
 def serialize_user_response(
     *,
     run_meta: RunMeta,
     entries: list[UserResponseEntry],
     created_at: str,
-    approval: UserResponseApproval | None = None,
+    plan_decision: UserPlanDecision | None = None,
     analysis_review: UserResponseAnalysisReview | None = None,
 ) -> str:
     """Return the canonical markdown text the HTML 'Export user
@@ -1125,7 +1150,7 @@ def serialize_user_response(
         "\n"
         "# User Response\n"
     )
-    has_approval = approval is not None and approval.approved
+    has_plan_decision = plan_decision is not None
     has_analysis_review = analysis_review is not None
     body_chunks: list[str] = []
     for e in entries:
@@ -1137,13 +1162,10 @@ def serialize_user_response(
         if e.rationale:
             chunk += f"- Rationale: {e.rationale.strip()}\n"
         body_chunks.append(chunk)
-    if not entries and not has_approval and not has_analysis_review:
+    if not entries and not has_plan_decision and not has_analysis_review:
         body_chunks.append("\n_(No user responses recorded.)_\n")
-    if has_approval:
-        chunk = "\n## APPROVAL\n- Approved: true\n"
-        if approval.implementation_option:
-            chunk += f"- Implementation-Option: {approval.implementation_option.strip()}\n"
-        body_chunks.append(chunk)
+    if plan_decision is not None:
+        body_chunks.append(_serialize_plan_decision(plan_decision))
     if analysis_review is not None:
         body_chunks.append(_serialize_analysis_review(analysis_review))
     return head + "".join(body_chunks)
@@ -1369,11 +1391,17 @@ def _plan_approval_section(ctx: PlanApprovalContext, run_meta: RunMeta) -> str:
     )
     return (
         '<section id="plan-approval">\n'
-        "  <h2>Plan Approval</h2>\n"
+        "  <h2>Plan Decision</h2>\n"
         f'  <label>구현 옵션: <select id="approval-option"{disabled}>{"".join(opts)}</select></label>\n'
-        f'  <label><input type="checkbox" id="approval-checkbox"{disabled}> '
-        "이 plan 을 승인합니다 — Export 시 sidecar 에 APPROVAL 블록으로 기록되고, "
-        "implementation 시작 마법사가 확인 후 적용합니다.</label>"
+        '  <fieldset id="plan-decision"><legend>판정</legend>'
+        f'<label><input type="radio" name="plan-decision-status" value="approved"{disabled}> '
+        "이 plan 을 승인합니다</label>"
+        '<label><input type="radio" name="plan-decision-status" '
+        'value="revision-requested"> 고쳐서 다시 가져오게 합니다</label>'
+        '<label><input type="radio" name="plan-decision-status" value="rejected"> '
+        "이 plan 을 반려합니다</label></fieldset>\n"
+        '  <label>사유 — 반려하거나 다시 고치게 할 때는 반드시 적어야 합니다'
+        '<textarea id="plan-decision-reason" rows="4"></textarea></label>'
         f"{reason_html}\n"
         "</section>\n"
     )

package/runtime/python/okstra_ctl/run.py

@@ -57,14 +57,19 @@ from .material import (
 from .final_report_schema import load_schema_version
 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,
-    ARTIFACT_ONLY_LEAD_RUNTIMES,
-    lead_runtime_info,
+from .application.resolve_assignment import (
+    resolve_assignment_runner,
+    resolve_lead_provider,
+)
+from .domain.host import (
+    HostCapabilityMismatch,
+    HostNotRegistered,
+    ProviderUnavailable,
 )
 from .model_discovery import normalize_execution_for_dispatch
 from .models import (
     ModelAssignment,
+    UnknownProviderError,
     default_model,
     lead_launch_argv,
     lead_launch_spec,
@@ -75,11 +80,8 @@ from .models import (
     resolve_model_metadata,
 )
 from .schema_excerpt import build_schema_excerpt
-from .runner_resolution import (
-    RunnerResolutionError,
-    native_provider_for_host,
-    resolve_runner,
-)
+from .registry.host_registry import default_host_registry
+from .registry.provider_registry import default_provider_registry
 from .report_contract import CURRENT_REPORT_SCHEMA_VERSION
 from .path_resolve import relative_to_project_root, resolve_user_file
 from .render import (
@@ -326,15 +328,16 @@ def _set_data_json_approved_true_if_present(path: Path) -> bool:
 PrepareError = _stage_targets.PrepareError
 
 
-_ALLOWED_LEAD_RUNTIMES = ALLOWED_LEAD_RUNTIMES
-
-
 def _normalize_lead_runtime(value: str) -> str:
     runtime = (value or "claude-code").strip()
-    if runtime not in _ALLOWED_LEAD_RUNTIMES:
-        allowed = ", ".join(_ALLOWED_LEAD_RUNTIMES)
-        raise PrepareError(f"unsupported lead runtime: {runtime} (allowed: {allowed})")
-    return runtime
+    registry = default_host_registry()
+    try:
+        return registry.resolve(runtime).descriptor.id
+    except HostNotRegistered as exc:
+        allowed = ", ".join(registry.ids())
+        raise PrepareError(
+            f"unsupported lead runtime: {runtime} (allowed: {allowed})"
+        ) from exc
 
 
 @dataclass
@@ -726,7 +729,8 @@ def _brief_sha256(path: Path) -> str:
 
 
 def _record_artifact_runtime_render_only_event(inp: PrepareInputs, ctx: dict) -> None:
-    if inp.lead_runtime not in ARTIFACT_ONLY_LEAD_RUNTIMES or not inp.render_only:
+    descriptor = default_host_registry().resolve(inp.lead_runtime).descriptor
+    if descriptor.session_accounting != "artifact-only" or not inp.render_only:
         return
     append_lead_event(
         Path(ctx["LEAD_EVENTS_PATH"]),
@@ -1446,9 +1450,20 @@ def _model_for_role(
 
 
 def _assignment_runner(lead_runtime: str, provider: str, role: str) -> str:
+    host_registry = default_host_registry()
+    provider_registry = default_provider_registry()
     try:
-        return resolve_runner(lead_runtime, provider, role).runner
-    except RunnerResolutionError as exc:
+        return resolve_assignment_runner(
+            host=host_registry.resolve(lead_runtime).descriptor,
+            provider=provider_registry.resolve(provider),
+            role=role,
+        ).runner
+    except (
+        HostCapabilityMismatch,
+        HostNotRegistered,
+        ProviderUnavailable,
+        UnknownProviderError,
+    ) as exc:
         raise PrepareError(str(exc)) from exc
 
 
@@ -1468,23 +1483,22 @@ def _resolve_worker_models(inp: PrepareInputs) -> dict:
             provider, overrides.get(provider, legacy.get(provider, "")),
             "analyser", default_override,
         )
-    native_lead_provider = native_provider_for_host(inp.lead_runtime)
-    requested_lead_provider = inp.lead_provider.strip().lower()
-    if (
-        native_lead_provider
-        and requested_lead_provider
-        and requested_lead_provider != native_lead_provider
-    ):
-        host_label = lead_runtime_info(inp.lead_runtime).agent_label
-        raise PrepareError(
-            f"{host_label.removesuffix(' CLI')} host requires provider "
-            f"{native_lead_provider!r} for the in-session lead; provider "
-            f"{requested_lead_provider!r} must be selected as a worker instead"
-        )
-    lead_provider = native_lead_provider or requested_lead_provider or "claude"
+    try:
+        lead_assignment = resolve_lead_provider(
+            host_id=inp.lead_runtime,
+            requested_provider=inp.lead_provider,
+            host_registry=default_host_registry(),
+            provider_registry=default_provider_registry(),
+        )
+    except (
+        HostCapabilityMismatch,
+        HostNotRegistered,
+        ProviderUnavailable,
+        UnknownProviderError,
+    ) as exc:
+        raise PrepareError(str(exc)) from exc
+    lead_provider = lead_assignment.provider
     report_writer_provider = inp.report_writer_provider.strip().lower() or "claude"
-    if not provider_supports_role(lead_provider, "lead"):
-        raise PrepareError(f"provider {lead_provider!r} does not support the lead role")
     if not provider_supports_role(report_writer_provider, "report-writer"):
         raise PrepareError(
             f"provider {report_writer_provider!r} does not support the report-writer role"
@@ -2736,7 +2750,7 @@ def main(argv: list[str]) -> int:
     p.add_argument(
         "--lead-runtime",
         default="claude-code",
-        choices=list(_ALLOWED_LEAD_RUNTIMES),
+        choices=list(default_host_registry().ids()),
         dest="lead_runtime",
         help=(
             "Lead runtime adapter. Default: claude-code. `codex` renders "
@@ -2964,8 +2978,7 @@ def main(argv: list[str]) -> int:
     else:
         print(f"okstra current run dir: {ctx['RUN_DIR']}")
         print(f"final report path: {ctx['FINAL_REPORT_PATH']}")
-        lead_runtime_name = ctx.get("LEAD_RUNTIME", "claude-code")
-        lead_provider = lead_runtime_info(lead_runtime_name).agent
+        lead_provider = ctx.get("LEAD_PROVIDER", "")
         launch = lead_launch_spec(lead_provider)
         print(f"lead model: {ctx['LEAD_MODEL']}")
         print(f"claude session id: {ctx['CLAUDE_SESSION_ID']}")
@@ -2977,30 +2990,39 @@ def main(argv: list[str]) -> int:
         # lead. The argv is assembled here rather than in the caller so provider
         # launch knowledge stays in the catalog and every front end — the bash
         # wrapper and the Node CLI — starts the lead identically.
-        prompt_file = Path(ctx["INSTRUCTION_SET_PATH"]) / "lead-execution-prompt.md"
-        machine = {
-            "leadRuntime": lead_runtime_name,
-            "leadProvider": lead_provider,
-            "leadExecutable": launch.executable,
-            "leadSessionId": ctx["CLAUDE_SESSION_ID"],
-            "leadModelExecutionValue": ctx["LEAD_MODEL_EXECUTION_VALUE"],
-            "projectRoot": ctx["PROJECT_ROOT"],
-            "promptFile": str(prompt_file),
-            # Non-empty only when starting this lead lowers a protection the
-            # user should agree to first. The front end asks; okstra does not
-            # waive it silently.
-            "sandboxWaiverNote": launch.sandbox_waiver_note,
-            "launchArgv": lead_launch_argv(
-                lead_provider,
-                model=ctx["LEAD_MODEL_EXECUTION_VALUE"],
-                session_id=ctx["CLAUDE_SESSION_ID"],
-                prompt=prompt_file.read_text(encoding="utf-8"),
-            ),
-        }
+        machine = _lead_launch_payload(ctx)
         print(f"__OKSTRA_LAUNCH__ {json.dumps(machine)}")
     return 0
 
 
+def _lead_launch_payload(ctx: dict[str, object]) -> dict[str, object]:
+    lead_runtime = str(ctx.get("LEAD_RUNTIME", "claude-code"))
+    lead_provider = str(ctx.get("LEAD_PROVIDER", ""))
+    launch = lead_launch_spec(lead_provider)
+    prompt_file = (
+        Path(str(ctx["INSTRUCTION_SET_PATH"])) / "lead-execution-prompt.md"
+    )
+    launch_argv = lead_launch_argv(
+        lead_provider,
+        model=str(ctx["LEAD_MODEL_EXECUTION_VALUE"]),
+        session_id=str(ctx["CLAUDE_SESSION_ID"]),
+        prompt=prompt_file.read_text(encoding="utf-8"),
+    )
+    launch_prefix_size = 1 + len(launch.sandbox_waiver)
+    return {
+        "leadRuntime": lead_runtime,
+        "leadProvider": lead_provider,
+        "leadExecutable": launch.executable,
+        "leadSessionId": ctx["CLAUDE_SESSION_ID"],
+        "leadModelExecutionValue": ctx["LEAD_MODEL_EXECUTION_VALUE"],
+        "projectRoot": ctx["PROJECT_ROOT"],
+        "promptFile": str(prompt_file),
+        "sandboxWaiverNote": launch.sandbox_waiver_note,
+        "launchArgv": launch_argv,
+        "launchRequestArgv": launch_argv[launch_prefix_size:],
+    }
+
+
 if __name__ == "__main__":
     import sys
     raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/session.py

@@ -186,7 +186,7 @@ cat >&2 <<EOF
 EOF
 
 cd "$PROJECT_ROOT"
-exec claude --resume "$SESSION_ID"
+exec "$HOME/.okstra/bin/okstra.sh" --resume-session "$SESSION_ID" --lead-runtime claude-code --project-root "$PROJECT_ROOT"
 """
     resume_command_path.write_text(body, encoding="utf-8")
     os.chmod(resume_command_path, 0o755)

package/runtime/python/okstra_ctl/stage_citations.py

@@ -9,6 +9,7 @@ which decides whether a re-run narrows or stays full.
 from __future__ import annotations
 
 import re
+from collections.abc import Iterator
 
 _RANGE = r"(?:[-–]|\bto\b|\bthrough\b)"
 _ITEM = rf"\d+(?:\s*{_RANGE}\s*\d+)?"
@@ -23,25 +24,61 @@ _ITEM_RE = re.compile(rf"(\d+)(?:\s*{_RANGE}\s*(\d+))?", re.IGNORECASE)
 RANGE_MAX_SPAN = 64
 
 
+def _stage_citation_items(text: str) -> Iterator[tuple[int, int | None]]:
+    """Each `stage`-anchored citation in *text* as `(start, end)`.
+
+    *end* is None for a bare number and the far endpoint for a range. Numbers
+    stay anchored to a word-initial `stage`/`stages` token on the same line;
+    harvesting bare numbers — or letting the anchor reach across a line break,
+    or match the tail of `Substage`/`Backstage` — would let any prose, including
+    a row disclaiming every stage, justify any stage.
+    """
+    for span in _LIST_RE.finditer(text):
+        for item in _ITEM_RE.finditer(span.group(1)):
+            end = item.group(2)
+            yield int(item.group(1)), int(end) if end is not None else None
+
+
 def cited_stage_numbers(text: str) -> set[int]:
     """Stage numbers *text* cites, in every prose form a planner writes.
 
-    Numbers stay anchored to a word-initial `stage`/`stages` token on the same
-    line; harvesting bare numbers — or letting the anchor reach across a line
-    break, or match the tail of `Substage`/`Backstage` — would let any prose,
-    including a row disclaiming every stage, justify any stage.
+    A range reaches every number between its endpoints here, which is what a
+    reader asking "could this touch stage 5" needs.
     """
     cited: set[int] = set()
+    for start, end in _stage_citation_items(text):
+        cited.add(start)
+        if end is None:
+            continue
+        cited.add(end)
+        # A reversed or absurdly wide range is a typo, not a citation of
+        # everything between its endpoints.
+        if 0 <= end - start <= RANGE_MAX_SPAN:
+            cited.update(range(start, end))
+    return cited
+
+
+def enumerated_stage_numbers(text: str) -> set[int]:
+    """Stage numbers *text* names one by one — a range's interior excluded.
+
+    The two readers of this grammar ask opposite questions, and a range answers
+    only one of them. The incremental-scope back-trace asks "could this answer
+    reach stage 5", so it must read `Stages 1-8` as reaching it — that is
+    `cited_stage_numbers`, and widening there is the safe direction. Coverage
+    provenance asks "did the planner confirm stage 5 satisfies this
+    requirement", and a range answers that for free: one `Stages 1-64` cell
+    stamps every stage in the map without the planner looking at any of them.
+
+    So the interior is dropped here and only hand-written numbers count. A
+    range's endpoints ARE hand-written and stay, which keeps `Stages 7-8`
+    honest while forcing the wide case to be spelled out. The cost of a
+    legitimately broad requirement is typing each number, and that typing is
+    the confirmation this check is asking for.
+    """
+    enumerated: set[int] = set()
     for span in _LIST_RE.finditer(text):
         for item in _ITEM_RE.finditer(span.group(1)):
-            start = int(item.group(1))
-            cited.add(start)
-            if item.group(2) is None:
-                continue
-            end = int(item.group(2))
-            cited.add(end)
-            # A reversed or absurdly wide range is a typo, not a citation of
-            # everything between its endpoints.
-            if 0 <= end - start <= RANGE_MAX_SPAN:
-                cited.update(range(start, end))
-    return cited
+            enumerated.add(int(item.group(1)))
+            if item.group(2) is not None:
+                enumerated.add(int(item.group(2)))
+    return enumerated

package/runtime/python/okstra_ctl/team.py

@@ -1,8 +1,9 @@
 """Neutral okstra team CLI for pane-backed worker dispatch.
 
-Outside cmux this is the external lead's door onto tmux panes. Under cmux it
-is every lead's door onto cmux surfaces, because okstra owns the panes there
-rather than the host. Which backend a run uses is read from its run manifest.
+Outside cmux this is the door onto tmux panes for hosts whose descriptor owns
+the team lifecycle. Under cmux it is every lead's door onto cmux surfaces,
+because okstra owns the panes there rather than the host. Which backend a run
+uses is read from its run manifest.
 """
 from __future__ import annotations
 
@@ -14,18 +15,23 @@ from typing import Any, Mapping, Sequence
 
 from . import cmux
 from . import tmux
+from .adapters.dispatch import provider_worker_wrappers
+from .adapters.dispatch.cmux import dispatch_port_for_terminal_backend
+from .application.dispatch_assignments import dispatch_assignments
 from .dispatch_core import (
     BACKEND_CMUX_PANE,
     BACKEND_TMUX_PANE,
     DispatchError,
     DispatchPlan,
     await_dispatches,
-    build_dispatch_plan,
     dispatch_plan,
 )
-from .runner_resolution import worker_wrapper_registry
+from .ports.worker_dispatch import WorkerDispatchRequest
+from .registry.host_registry import default_host_registry
+from .registry.provider_registry import default_provider_registry
 
-_SUPPORTED_WRAPPERS = worker_wrapper_registry()
+
+_SUPPORTED_WRAPPERS = provider_worker_wrappers(default_provider_registry())
 _TERMINAL_STATUSES = {"completed", "timeout", "error", "not-run"}
 
 
@@ -92,33 +98,43 @@ def _dispatch(args) -> int:
     if args.jobs_file and args.workers:
         raise DispatchError("--jobs-file and --workers cannot be combined")
     manifest = _load_manifest(args.project_root, args.run_manifest)
-    _validate_external_manifest(manifest)
-    requested = _parse_workers(args.workers)
-    plan = build_dispatch_plan(
+    terminal_backend = _manifest_backend(manifest)
+    lead_runtime = _require_string(manifest, "leadRuntime")
+    fallback_port = default_host_registry().resolve(
+        lead_runtime
+    ).worker_dispatch()
+    port = dispatch_port_for_terminal_backend(
+        terminal_backend,
+        fallback_port,
+        supported_worker_wrappers=_SUPPORTED_WRAPPERS,
+        unsupported_worker_label=f"{lead_runtime} lead",
+        required_lead_runtime=None if _is_cmux_run(manifest) else lead_runtime,
+    )
+    request = WorkerDispatchRequest(
         project_root=Path(args.project_root),
-        run_manifest_path=Path(args.run_manifest),
+        run_manifest=Path(args.run_manifest),
         workspace_root=Path(args.workspace_root),
         okstra_bin=Path(args.okstra_bin),
-        requested_workers=requested,
+        requested_workers=tuple(_parse_workers(args.workers)),
         idle_timeout_seconds=args.idle_timeout_seconds,
-        required_lead_runtime=None if _is_cmux_run(manifest) else "external",
-        default_backend=_manifest_backend(manifest),
-        supported_worker_wrappers=_SUPPORTED_WRAPPERS,
-        unsupported_worker_label="external lead",
         dispatch_kind=args.dispatch_kind,
         jobs_file=Path(args.jobs_file) if args.jobs_file else None,
     )
+    plan = dispatch_assignments(request, port)
+    backend_plan = plan.backend_plan
+    if backend_plan is None:
+        raise DispatchError("team dispatch did not produce a backend plan")
     if args.dry_run:
-        _print_json(plan.to_payload(dry_run=True))
+        _print_json(backend_plan.to_payload(dry_run=True))
         return 0
-    result = dispatch_plan(plan, wait=False)
-    _print_json(plan.to_payload(dry_run=False))
+    result = dispatch_plan(backend_plan, wait=False)
+    _print_json(backend_plan.to_payload(dry_run=False))
     return result
 
 
 def _await(args) -> int:
     manifest = _load_manifest(args.project_root, args.run_manifest)
-    _validate_external_manifest(manifest)
+    _validate_team_manifest(manifest)
     plan = _plan_for_existing(Path(args.project_root), Path(args.workspace_root), Path(args.run_manifest), manifest)
     code = await_dispatches(
         plan,
@@ -135,7 +151,7 @@ def _await(args) -> int:
 
 def _teardown(args) -> int:
     manifest = _load_manifest(args.project_root, args.run_manifest)
-    _validate_external_manifest(manifest)
+    _validate_team_manifest(manifest)
     project_root = Path(args.project_root).resolve()
     team_state_path = _resolve_project_path(project_root, _require_string(manifest, "teamStatePath"))
     team_state = _load_json(team_state_path, "team-state")
@@ -242,20 +258,16 @@ def _is_cmux_run(manifest: Mapping[str, Any]) -> bool:
     return _manifest_backend(manifest) == BACKEND_CMUX_PANE
 
 
-def _validate_external_manifest(manifest: Mapping[str, Any]) -> None:
-    runtime = manifest.get("leadRuntime")
-    if runtime == "external":
-        return
+def _validate_team_manifest(manifest: Mapping[str, Any]) -> None:
     if _is_cmux_run(manifest):
-        # Under cmux okstra owns the panes for every lead, so this command is no
-        # longer the external lead's private door and the advice below no longer
-        # applies — there is nowhere else for a codex or Claude Code lead to go.
         return
-    if runtime == "codex":
-        raise DispatchError("use okstra codex-dispatch for leadRuntime=codex")
-    if runtime == "claude-code":
-        raise DispatchError("use Claude Code TeamCreate/Agent flow for leadRuntime=claude-code")
-    raise DispatchError(f"unsupported leadRuntime for okstra team: {runtime}")
+    runtime = _require_string(manifest, "leadRuntime")
+    descriptor = default_host_registry().resolve(runtime).descriptor
+    if descriptor.launch_mode == "team":
+        return
+    raise DispatchError(
+        f"leadRuntime={descriptor.id} does not use the okstra team lifecycle"
+    )
 
 
 def _load_manifest(project_root: str, run_manifest: str) -> dict[str, Any]: