okstra 0.163.2 → 0.164.0

package/runtime/python/okstra_ctl/render.py

@@ -30,11 +30,18 @@ from okstra_project.dirs import TASK_MANIFEST_FILENAME, OKSTRA_DIR_NAME, project
 # 이는 silent drift 위험이 있어 SSOT import 로 통합한다.
 from . import fix_cycles
 from .analysis_inputs import ANALYSIS_TASK_TYPES
+from .application.resolve_assignment import (
+    resolve_assignment_runner,
+    resolve_lead_provider,
+)
+from .application.dispatch_assignments import dispatch_assignments
+from .adapters.dispatch import default_worker_dispatch_port, with_worker_dispatch
+from .adapters.dispatch.cmux import dispatch_port_for_terminal_backend
 from .paths import okstra_home
-from .dispatch_state import BACKEND_CMUX_PANE
-from .lead_runtime import lead_runtime_info, with_cmux_dispatch
 from .models import UnknownProviderError, provider_ids, provider_spec
-from .runner_resolution import native_provider_for_host
+from .ports.worker_dispatch import WorkerDispatchRequest
+from .registry.host_registry import default_host_registry
+from .registry.provider_registry import default_provider_registry
 from .path_hints import compact_active_run_context, hydrate_run_context
 from .paths import task_timeline_file
 from .worker_artifacts import artifacts_from_context
@@ -80,27 +87,49 @@ def _lead_runtime(ctx: dict) -> str:
     return ctx.get("LEAD_RUNTIME", "") or "claude-code"
 
 
-def _lead_info(ctx: dict):
-    info = lead_runtime_info(_lead_runtime(ctx))
-    if ctx.get("TERMINAL_BACKEND") == BACKEND_CMUX_PANE:
-        return with_cmux_dispatch(info)
-    return info
+def _lead_descriptor(ctx: dict):
+    return default_host_registry().resolve(_lead_runtime(ctx)).descriptor
+
+
+def _worker_dispatch_plan(ctx: dict):
+    host_adapter = default_host_registry().resolve(_lead_runtime(ctx))
+    fallback_port = default_worker_dispatch_port(host_adapter.descriptor)
+    port = dispatch_port_for_terminal_backend(
+        ctx.get("TERMINAL_BACKEND", ""),
+        fallback_port,
+    )
+    decorated = with_worker_dispatch(host_adapter, port)
+    request = WorkerDispatchRequest(
+        project_root=Path(ctx.get("PROJECT_ROOT", "")),
+        run_manifest=Path(ctx.get("RUN_MANIFEST_PATH", "")),
+    )
+    return dispatch_assignments(request, decorated.worker_dispatch())
 
 
 def _lead_agent(ctx: dict) -> str:
-    return _lead_info(ctx).agent
+    return _lead_descriptor(ctx).agent_id
 
 
 def _lead_agent_label(ctx: dict) -> str:
-    return _lead_info(ctx).agent_label
+    return _lead_descriptor(ctx).agent_label
 
 
 def _lead_role(ctx: dict) -> str:
-    return _lead_info(ctx).role
+    return _lead_descriptor(ctx).role
+
+
+def _lead_adapter(ctx: dict, plan) -> dict:
+    descriptor = default_host_registry().resolve(_lead_runtime(ctx)).descriptor
+    return {
+        "name": plan.adapter_name or descriptor.id,
+        "dispatchMode": plan.dispatch_mode or descriptor.dispatch_mode,
+        "sessionAccounting": descriptor.session_accounting,
+    }
 
 
-def _lead_adapter(ctx: dict) -> dict:
-    return _lead_info(ctx).adapter_payload()
+def _lead_adapter_contract(ctx: dict, plan) -> str:
+    descriptor = default_host_registry().resolve(_lead_runtime(ctx)).descriptor
+    return plan.relay_contract or descriptor.relay_contract
 
 
 def _runtime_resolution(ctx: dict) -> dict:
@@ -257,31 +286,71 @@ def _resolve_workers(ctx: dict) -> list[str]:
     ]
 
 
-def _assignment_runner_for_ctx(ctx: dict, provider: str) -> str:
-    native_provider = native_provider_for_host(_lead_runtime(ctx))
-    return "native-session" if provider == native_provider else "cli-wrapper"
+def _assignment_runner_for_ctx(
+    ctx: dict,
+    provider: str,
+    role: str,
+    requested_runner: str = "",
+) -> str:
+    host = default_host_registry().resolve(_lead_runtime(ctx)).descriptor
+    spec = default_provider_registry().resolve(provider)
+    return resolve_assignment_runner(
+        host=host,
+        provider=spec,
+        role=role,
+        requested_runner=requested_runner,
+    ).runner
+
+
+def _resolved_lead_assignment(
+    ctx: dict,
+    requested_provider: str,
+    requested_runner: str = "",
+):
+    host_registry = default_host_registry()
+    provider_registry = default_provider_registry()
+    assignment = resolve_lead_provider(
+        host_id=_lead_runtime(ctx),
+        requested_provider=requested_provider,
+        host_registry=host_registry,
+        provider_registry=provider_registry,
+    )
+    if requested_runner:
+        resolution = resolve_assignment_runner(
+            host=host_registry.resolve(_lead_runtime(ctx)).descriptor,
+            provider=provider_registry.resolve(assignment.provider),
+            role="lead",
+            requested_runner=requested_runner,
+        )
+        return assignment.provider, resolution.runner
+    return assignment.provider, assignment.runner
 
 
 def _lead_assignment(ctx: dict) -> dict:
+    parsed = None
     raw = ctx.get("LEAD_ASSIGNMENT_JSON", "")
     if raw:
         try:
-            parsed = json.loads(raw)
-            if isinstance(parsed, dict):
-                return parsed
+            candidate = json.loads(raw)
+            if isinstance(candidate, dict):
+                parsed = candidate
         except json.JSONDecodeError:
             pass
-    provider = (
-        ctx.get("LEAD_PROVIDER", "")
-        or native_provider_for_host(_lead_runtime(ctx))
-        or "claude"
+    source = parsed or {}
+    provider, runner = _resolved_lead_assignment(
+        ctx,
+        source.get("provider", "") or ctx.get("LEAD_PROVIDER", ""),
+        source.get("runner", ""),
     )
     return {
+        **source,
         "role": "lead",
         "provider": provider,
-        "model": ctx.get("LEAD_MODEL", ""),
-        "modelExecutionValue": ctx.get("LEAD_MODEL_EXECUTION_VALUE", ""),
-        "runner": _assignment_runner_for_ctx(ctx, provider),
+        "model": source.get("model", ctx.get("LEAD_MODEL", "")),
+        "modelExecutionValue": source.get(
+            "modelExecutionValue", ctx.get("LEAD_MODEL_EXECUTION_VALUE", "")
+        ),
+        "runner": runner,
     }
 
 
@@ -291,7 +360,7 @@ def _worker_assignments(ctx: dict) -> list[dict]:
         try:
             parsed = json.loads(raw)
             if isinstance(parsed, list) and all(isinstance(row, dict) for row in parsed):
-                return parsed
+                return [_resolved_worker_assignment(ctx, row) for row in parsed]
         except json.JSONDecodeError:
             pass
     catalog = _worker_catalog(ctx, include_assignments=False)
@@ -302,12 +371,39 @@ def _worker_assignments(ctx: dict) -> list[dict]:
             "provider": catalog[worker_id]["agent"],
             "model": catalog[worker_id]["model"],
             "modelExecutionValue": catalog[worker_id]["modelExecutionValue"],
-            "runner": _assignment_runner_for_ctx(ctx, catalog[worker_id]["agent"]),
+            "runner": _assignment_runner_for_ctx(
+                ctx,
+                catalog[worker_id]["agent"],
+                "report-writer" if worker_id == "report-writer" else "analyser",
+            ),
         }
         for worker_id in _resolve_workers(ctx)
     ]
 
 
+def _resolved_worker_assignment(ctx: dict, source: dict) -> dict:
+    worker_id = source.get("workerId", "")
+    role = source.get("role", "") or (
+        "report-writer" if worker_id == "report-writer" else "analyser"
+    )
+    provider = source.get("provider", "") or _fallback_worker_provider(
+        ctx, worker_id
+    )
+    runner = _assignment_runner_for_ctx(
+        ctx,
+        provider,
+        role,
+        source.get("runner", ""),
+    )
+    return {
+        **source,
+        "workerId": worker_id,
+        "role": role,
+        "provider": provider,
+        "runner": runner,
+    }
+
+
 def _worker_catalog(ctx: dict, *, include_assignments: bool = True) -> dict:
     assignments = {} if not include_assignments else {
         row.get("workerId"): row for row in _worker_assignments(ctx)
@@ -329,7 +425,11 @@ def _worker_catalog(ctx: dict, *, include_assignments: bool = True) -> dict:
             "agentLabel": provider_info.display_label,
             "provider": provider,
             "runner": assignment.get(
-                "runner", _assignment_runner_for_ctx(ctx, provider),
+                "runner", _assignment_runner_for_ctx(
+                    ctx,
+                    provider,
+                    "report-writer" if worker_id == "report-writer" else "analyser",
+                ),
             ),
             "model": assignment.get("model", model),
             "modelExecutionValue": assignment.get("modelExecutionValue", execution),
@@ -551,6 +651,7 @@ def render_active_run_context(active_context_path: str, ctx: dict) -> None:
 def render_team_state(team_state_path: str, ctx: dict) -> None:
     selected = _resolve_workers(ctx)
     catalog = _worker_catalog(ctx)
+    worker_dispatch_plan = _worker_dispatch_plan(ctx)
     workers = []
     for w in selected:
         m = catalog[w]
@@ -577,7 +678,7 @@ def render_team_state(team_state_path: str, ctx: dict) -> None:
         "leadRuntime": _lead_runtime(ctx),
         "leadAssignment": _lead_assignment(ctx),
         "workerAssignments": _worker_assignments(ctx),
-        "leadAdapter": _lead_adapter(ctx),
+        "leadAdapter": _lead_adapter(ctx, worker_dispatch_plan),
         "leadEventsPath": ctx.get("LEAD_EVENTS_RELATIVE_PATH", ""),
         "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
         "workflowState": ctx.get("CURRENT_RUN_STATUS", ""),
@@ -1112,6 +1213,7 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
         except Exception:
             existing = {}
     reviewers = _resolve_workers(ctx)
+    worker_dispatch_plan = _worker_dispatch_plan(ctx)
     catalog = _worker_catalog(ctx)
     required_worker_roles = _required_worker_roles(ctx, reviewers)
     worker_prompt_paths = {item: catalog[item]["promptPath"] for item in reviewers}
@@ -1170,7 +1272,7 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
         "leadRuntime": _lead_runtime(ctx),
         "leadAssignment": _lead_assignment(ctx),
         "workerAssignments": _worker_assignments(ctx),
-        "leadAdapter": _lead_adapter(ctx),
+        "leadAdapter": _lead_adapter(ctx, worker_dispatch_plan),
         "workCategory": work_category,
         # user-managed status (set-work-status CLI) — carried across re-renders
         "workStatus": existing.get("workStatus", ""),
@@ -1308,7 +1410,7 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
         "leadSession": {
             "sessionId": ctx.get("CLAUDE_SESSION_ID", ""),
             "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
-            "accounting": _lead_info(ctx).session_accounting,
+            "accounting": _lead_descriptor(ctx).session_accounting,
         },
         "convergence": convergence_block,
         "createdAt": existing.get("createdAt") or ctx.get("RUN_TIMESTAMP_ISO", ""),
@@ -1418,6 +1520,7 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         except Exception:
             task_manifest = {}
     reviewers = _resolve_workers(ctx)
+    worker_dispatch_plan = _worker_dispatch_plan(ctx)
     catalog = _worker_catalog(ctx)
     required_worker_roles = _required_worker_roles(ctx, reviewers)
     worker_prompt_paths = {item: catalog[item]["promptPath"] for item in reviewers}
@@ -1452,7 +1555,7 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "runtimeResolution": _runtime_resolution(ctx),
         "leadAssignment": _lead_assignment(ctx),
         "workerAssignments": _worker_assignments(ctx),
-        "leadAdapter": _lead_adapter(ctx),
+        "leadAdapter": _lead_adapter(ctx, worker_dispatch_plan),
         "workCategory": task_manifest.get(
             "workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")
         ),
@@ -1957,6 +2060,7 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     selected = _resolve_workers(ctx)
     catalog = _worker_catalog(ctx)
     lead_runtime = _lead_runtime(ctx)
+    worker_dispatch_plan = _worker_dispatch_plan(ctx)
     lead_role = _lead_role(ctx)
     lead_agent_label = _lead_agent_label(ctx)
     lead_model = ctx.get("LEAD_MODEL", "")
@@ -1966,7 +2070,7 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
         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
+        home_prompts / _lead_adapter_contract(ctx, worker_dispatch_plan)
     )
     context_loader_path = ctx.get("OKSTRA_CONTEXT_LOADER_PATH") or str(
         home_prompts / "lead" / "context-loader.md"
@@ -2163,27 +2267,21 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
         "schema and write rules. Do not re-inline either contract."
     )
 
-    if lead_runtime == "external":
+    lead_descriptor = _lead_descriptor(ctx)
+    if lead_descriptor.has_claude_session:
         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."
-        )
-    elif lead_runtime == "codex":
-        lead_session_block = (
-            "## Session\n"
-            "\n"
-            "- Lead runtime: `codex`\n"
-            "- Codex run resume is artifact/checkpoint based; `okstra codex-run` "
-            "does not create a Claude session id."
+            f"- Session ID: `{ctx.get('CLAUDE_SESSION_ID', '')}`\n"
+            f"- Resume: `{ctx.get('CLAUDE_RESUME_COMMAND_RELATIVE_PATH', '')}`"
         )
     else:
         lead_session_block = (
             "## Session\n"
             "\n"
-            f"- Session ID: `{ctx.get('CLAUDE_SESSION_ID', '')}`\n"
-            f"- Resume: `{ctx.get('CLAUDE_RESUME_COMMAND_RELATIVE_PATH', '')}`"
+            f"- Lead runtime: `{lead_descriptor.id}`\n"
+            f"- Lead session accounting: {lead_descriptor.session_accounting}\n"
+            "- Resume behavior is provided by the selected host lead-session port."
         )
 
     # Compute results (deterministic from ctx, 덮어쓰기)

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)