okstra 0.163.2 → 0.164.0

package/runtime/python/okstra_ctl/lead_runtime.py

@@ -1,115 +0,0 @@
-"""Lead runtime metadata shared by render and prepare paths."""
-from __future__ import annotations
-
-from dataclasses import dataclass, replace
-
-
-@dataclass(frozen=True)
-class LeadRuntimeInfo:
-    runtime: str
-    agent: str
-    agent_label: str
-    role: str
-    adapter_name: str
-    adapter_dispatch_mode: str
-    session_accounting: str
-    has_claude_session: bool
-    adapter_contract_relative_path: str
-
-    def adapter_payload(self) -> dict[str, str]:
-        return {
-            "name": self.adapter_name,
-            "dispatchMode": self.adapter_dispatch_mode,
-            "sessionAccounting": self.session_accounting,
-        }
-
-
-ARTIFACT_ONLY_LEAD_RUNTIMES = frozenset({"codex", "antigravity", "external"})
-
-# Not a lead runtime — an adapter selected by the environment, so it is absent
-# from ALLOWED_LEAD_RUNTIMES and from _LEAD_RUNTIMES on purpose. `--lead-runtime
-# cmux` is not a thing a user can ask for; see `with_cmux_dispatch`.
-CMUX_ADAPTER_NAME = "cmux"
-CMUX_ADAPTER_RELATIVE_PATH = "lead/adapters/cmux.md"
-
-_LEAD_RUNTIMES = {
-    "claude-code": LeadRuntimeInfo(
-        runtime="claude-code",
-        agent="claude",
-        agent_label="Claude Code",
-        role="Claude lead",
-        adapter_name="claude-code",
-        adapter_dispatch_mode="team",
-        session_accounting="claude-jsonl",
-        has_claude_session=True,
-        adapter_contract_relative_path="lead/adapters/claude-code.md",
-    ),
-    "codex": LeadRuntimeInfo(
-        runtime="codex",
-        agent="codex",
-        agent_label="Codex CLI",
-        role="Codex lead",
-        adapter_name="codex",
-        adapter_dispatch_mode="render-only",
-        session_accounting="artifact-only",
-        has_claude_session=False,
-        adapter_contract_relative_path="lead/adapters/codex.md",
-    ),
-    "antigravity": LeadRuntimeInfo(
-        runtime="antigravity",
-        agent="antigravity",
-        agent_label="Antigravity CLI",
-        role="Antigravity lead",
-        adapter_name="antigravity",
-        adapter_dispatch_mode="render-only",
-        session_accounting="artifact-only",
-        has_claude_session=False,
-        adapter_contract_relative_path="lead/adapters/antigravity.md",
-    ),
-    "external": LeadRuntimeInfo(
-        runtime="external",
-        agent="external",
-        agent_label="External harness",
-        role="Okstra lead",
-        adapter_name="external",
-        adapter_dispatch_mode="render-only",
-        session_accounting="artifact-only",
-        has_claude_session=False,
-        adapter_contract_relative_path="lead/adapters/external.md",
-    ),
-}
-
-
-# Derived rather than restated: a hand-written copy of the registry's own keys
-# is a list that can disagree with the thing it describes.
-ALLOWED_LEAD_RUNTIMES = tuple(_LEAD_RUNTIMES)
-
-
-def lead_runtime_info(runtime: str) -> LeadRuntimeInfo:
-    try:
-        return _LEAD_RUNTIMES[runtime]
-    except KeyError as exc:
-        allowed = ", ".join(ALLOWED_LEAD_RUNTIMES)
-        raise ValueError(f"unsupported lead runtime: {runtime} (allowed: {allowed})") from exc
-
-
-def is_artifact_only_runtime(runtime: str) -> bool:
-    return runtime in ARTIFACT_ONLY_LEAD_RUNTIMES
-
-
-def with_cmux_dispatch(info: LeadRuntimeInfo) -> LeadRuntimeInfo:
-    """The same lead, minus the two fields cmux takes over.
-
-    On the cmux path okstra owns the worker panes rather than the host, so
-    "which adapter" and "does this lead dispatch or only render" stop depending
-    on who the lead is — they are the same for every runtime. Overriding the two
-    fields keeps that answer in one adapter file rather than repeating it in
-    four. Everything else (agent, label, role, session accounting) still
-    describes the lead itself and is left untouched.
-    """
-    return replace(
-        info,
-        adapter_name=CMUX_ADAPTER_NAME,
-        adapter_dispatch_mode="team",
-        adapter_contract_relative_path=CMUX_ADAPTER_RELATIVE_PATH,
-    )

package/runtime/python/okstra_ctl/runner_resolution.py

@@ -1,103 +0,0 @@
-"""Resolve native versus CLI execution from host and provider capabilities."""
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from .models import (
-    UnknownProviderError,
-    provider_spec,
-    provider_supports_role,
-    provider_wrappers,
-)
-
-NATIVE_SESSION = "native-session"
-CLI_WRAPPER = "cli-wrapper"
-RUNNER_VALUES = frozenset({NATIVE_SESSION, CLI_WRAPPER})
-
-_HOST_NATIVE_PROVIDERS = {
-    "claude-code": frozenset({"claude"}),
-    "codex": frozenset({"codex"}),
-    "antigravity": frozenset({"antigravity"}),
-    "external": frozenset(),
-}
-
-
-def native_provider_for_host(host_runtime: str) -> str:
-    """Return the single provider owned by an in-session host, if any."""
-    providers = _HOST_NATIVE_PROVIDERS.get(host_runtime)
-    if providers is None:
-        allowed = ", ".join(_HOST_NATIVE_PROVIDERS)
-        raise RunnerResolutionError(
-            f"unknown host runtime {host_runtime!r}. Allowed values: {allowed}"
-        )
-    return next(iter(providers), "")
-
-
-class RunnerResolutionError(ValueError):
-    """Raised when an assignment cannot run on the selected host."""
-
-
-@dataclass(frozen=True)
-class RunnerResolution:
-    runner: str
-    wrapper: str
-    reason: str
-
-
-def resolve_runner(
-    host_runtime: str,
-    provider: str,
-    role: str,
-    requested_runner: str = "",
-) -> RunnerResolution:
-    """Resolve an assignment without inferring the host from installed CLIs."""
-    native_providers = _HOST_NATIVE_PROVIDERS.get(host_runtime)
-    if native_providers is None:
-        allowed = ", ".join(_HOST_NATIVE_PROVIDERS)
-        raise RunnerResolutionError(
-            f"unknown host runtime {host_runtime!r}. Allowed values: {allowed}"
-        )
-    try:
-        spec = provider_spec(provider)
-    except UnknownProviderError as exc:
-        raise RunnerResolutionError(str(exc)) from exc
-    if not provider_supports_role(provider, role):
-        raise RunnerResolutionError(
-            f"provider {provider!r} does not support role {role!r}"
-        )
-    requested = (requested_runner or "").strip()
-    if requested and requested not in RUNNER_VALUES:
-        allowed = ", ".join(sorted(RUNNER_VALUES))
-        raise RunnerResolutionError(
-            f"unknown runner {requested!r}. Allowed values: {allowed}"
-        )
-    if requested == NATIVE_SESSION and provider not in native_providers:
-        raise RunnerResolutionError(
-            f"host runtime {host_runtime!r} does not provide native {provider!r} execution"
-        )
-    if requested == NATIVE_SESSION or (not requested and provider in native_providers):
-        return RunnerResolution(
-            runner=NATIVE_SESSION,
-            wrapper="",
-            reason=f"{host_runtime} provides native {provider} execution",
-        )
-    if not spec.wrapper:
-        raise RunnerResolutionError(
-            f"provider {provider!r} has no CLI wrapper for role {role!r}"
-        )
-    return RunnerResolution(
-        runner=CLI_WRAPPER,
-        wrapper=spec.wrapper,
-        reason=f"{host_runtime} uses the registered {provider} CLI wrapper",
-    )
-
-
-def worker_wrapper_registry(report_writer_provider: str = "claude") -> dict[str, str]:
-    """Worker-id wrapper map for dispatch front ends."""
-    wrappers = provider_wrappers("analyser")
-    report_writer = provider_spec(report_writer_provider)
-    if not provider_supports_role(report_writer_provider, "report-writer"):
-        raise RunnerResolutionError(
-            f"provider {report_writer_provider!r} does not support report-writer"
-        )
-    return {**wrappers, "report-writer": report_writer.wrapper}

package/src/lib/runtime-readiness.mjs

@@ -1,90 +0,0 @@
-import { promises as fs } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-
-const WORKSPACE_TRUST_CHECK_ID = "workspace-trust";
-
-function ready(runtime, check) {
-  return { runtime, status: "ready", checks: check ? [check] : [] };
-}
-
-function blocked(runtime) {
-  return {
-    runtime,
-    status: "blocked",
-    checks: [{
-      id: WORKSPACE_TRUST_CHECK_ID,
-      status: "required",
-      action: "restart-and-trust",
-    }],
-  };
-}
-
-function unknown(runtime) {
-  return {
-    runtime,
-    status: "unknown",
-    checks: [{
-      id: WORKSPACE_TRUST_CHECK_ID,
-      status: "unavailable",
-      action: "open-project-and-trust",
-    }],
-  };
-}
-
-function isJsonObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-async function hasProjectSettings(projectRoot) {
-  try {
-    await fs.lstat(join(projectRoot, ".claude", "settings.local.json"));
-    return true;
-  } catch (error) {
-    if (error?.code === "ENOENT") return false;
-    throw error;
-  }
-}
-
-async function checkClaudeCodeReadiness({ projectRoot, homeDir }) {
-  const runtime = "claude-code";
-  try {
-    if (!(await hasProjectSettings(projectRoot))) {
-      return ready(runtime, {
-        id: WORKSPACE_TRUST_CHECK_ID,
-        status: "not-applicable",
-      });
-    }
-
-    const rawState = await fs.readFile(join(homeDir, ".claude.json"), "utf8");
-    const state = JSON.parse(rawState);
-    if (!isJsonObject(state?.projects)) return unknown(runtime);
-
-    const projectState = state.projects[resolve(projectRoot)];
-    if (projectState === undefined) return blocked(runtime);
-    if (!isJsonObject(projectState)) return unknown(runtime);
-    if (projectState.hasTrustDialogAccepted === true) {
-      return ready(runtime, { id: WORKSPACE_TRUST_CHECK_ID, status: "accepted" });
-    }
-    if (projectState.hasTrustDialogAccepted === false
-        || projectState.hasTrustDialogAccepted === null
-        || projectState.hasTrustDialogAccepted === undefined) {
-      return blocked(runtime);
-    }
-    return unknown(runtime);
-  } catch {
-    return unknown(runtime);
-  }
-}
-
-export async function checkRuntimeReadiness({
-  runtime,
-  projectRoot,
-  homeDir = homedir(),
-}) {
-  const selectedRuntime = runtime ?? "auto";
-  if (selectedRuntime !== "claude-code") {
-    return ready(selectedRuntime);
-  }
-  return checkClaudeCodeReadiness({ projectRoot, homeDir });
-}

package/src/lib/runtime-resolver.mjs

@@ -1,123 +0,0 @@
-export const RUNTIME_AUTO = "auto";
-export const EXPLICIT_RUNTIMES = ["claude-code", "codex", "antigravity", "external"];
-export const VALID_RUNTIME_REQUESTS = [RUNTIME_AUTO, ...EXPLICIT_RUNTIMES, "all"];
-
-const VALID_HOSTS = new Set(EXPLICIT_RUNTIMES);
-const VALID_REQUESTS = new Set(VALID_RUNTIME_REQUESTS);
-
-function clean(value) {
-  return String(value ?? "").trim();
-}
-
-export function normalizeRuntimeRequest(value) {
-  const runtime = clean(value) || RUNTIME_AUTO;
-  if (!VALID_REQUESTS.has(runtime)) {
-    throw new Error(`unknown runtime '${runtime}' (expected: ${VALID_RUNTIME_REQUESTS.join(", ")})`);
-  }
-  return runtime;
-}
-
-function normalizeCapabilities(capabilities = {}) {
-  return {
-    claudeAssetsInstalled: capabilities.claudeAssetsInstalled === true,
-    codexCliAvailable: capabilities.codexCliAvailable === true,
-    tmuxAvailable: capabilities.tmuxAvailable === true,
-    claudeSkillHandoff: capabilities.claudeSkillHandoff === true,
-  };
-}
-
-function explicitResult(runtime) {
-  return {
-    ok: true,
-    requestedRuntime: runtime,
-    resolvedRuntime: runtime,
-    host: "explicit",
-    confidence: "high",
-    reason: `Explicit runtime '${runtime}' requested.`,
-    fallbackFrom: null,
-    warnings: [],
-  };
-}
-
-const RUNTIME_FLAG_COMMANDS = new Set(["install", "ensure-installed", "doctor"]);
-
-function explicitRuntimeFlag(command) {
-  return RUNTIME_FLAG_COMMANDS.has(command) ? "--runtime" : "--lead-runtime";
-}
-
-function okResult({ requestedRuntime, resolvedRuntime, host, reason, warnings = [] }) {
-  return {
-    ok: true,
-    requestedRuntime,
-    resolvedRuntime,
-    host,
-    confidence: "high",
-    reason,
-    fallbackFrom: null,
-    warnings,
-  };
-}
-
-function failResult(requestedRuntime, reason, warnings = []) {
-  return {
-    ok: false,
-    requestedRuntime,
-    resolvedRuntime: null,
-    host: "unknown",
-    confidence: "low",
-    reason,
-    fallbackFrom: null,
-    warnings,
-  };
-}
-
-export function resolveRuntime({
-  requestedRuntime = RUNTIME_AUTO,
-  command = "run",
-  env = {},
-  capabilities = {},
-} = {}) {
-  const request = normalizeRuntimeRequest(requestedRuntime);
-  const caps = normalizeCapabilities(capabilities);
-
-  if (request !== RUNTIME_AUTO) return explicitResult(request);
-
-  const rawHost = clean(env?.OKSTRA_RUNTIME_HOST);
-  if (rawHost) {
-    if (!VALID_HOSTS.has(rawHost)) {
-      return failResult(
-        request,
-        `invalid OKSTRA_RUNTIME_HOST '${rawHost}' (expected: ${EXPLICIT_RUNTIMES.join("|")}).`,
-      );
-    }
-    return okResult({
-      requestedRuntime: request,
-      resolvedRuntime: rawHost,
-      host: rawHost,
-      reason: `OKSTRA_RUNTIME_HOST=${rawHost} selected runtime '${rawHost}'.`,
-    });
-  }
-
-  if (caps.claudeSkillHandoff) {
-    return okResult({
-      requestedRuntime: request,
-      resolvedRuntime: "claude-code",
-      host: "claude-code",
-      reason: "Claude Code skill handoff selected runtime 'claude-code'.",
-    });
-  }
-
-  if (caps.tmuxAvailable) {
-    return okResult({
-      requestedRuntime: request,
-      resolvedRuntime: "external",
-      host: "generic-terminal",
-      reason: "No Claude Code or Codex host signal; tmux is available.",
-    });
-  }
-
-  return failResult(
-    request,
-    `host unknown: set OKSTRA_RUNTIME_HOST=claude-code|codex|antigravity|external or pass ${explicitRuntimeFlag(command)} explicitly.`,
-  );
-}