okstra 0.174.0 → 0.176.0

package/runtime/python/okstra_ctl/adapters/providers/kimi/adapter.py

@@ -1,5 +1,12 @@
 """Bundled Kimi provider catalog."""
-from okstra_ctl.domain.provider import LeadLaunchSpec, ModelSpec, ProviderSpec
+from typing import Any, Mapping
+from okstra_ctl.domain.provider import (
+    LeadLaunchSpec,
+    ModelSpec,
+    ProviderSpec,
+    ServedModelAttestation,
+)
+from okstra_ctl.domain.role import ALL_ROLE_TOKENS
 from okstra_ctl.domain.worker_exec import (
     STREAM_JSON,
     ExecCommand,
@@ -10,18 +17,33 @@ from okstra_ctl.domain.worker_stream import content_block_events
 
 
 KIMI = {
-    "kimi-k2.7-code": ModelSpec(
-        "Kimi K2.7 Code", "kimi-k2.7-code", (0.95, 0.19, 4.00), in_picker=True
-    ),
-    "kimi k2.7 code": ModelSpec("Kimi K2.7 Code", "kimi-k2.7-code"),
-    "kimi-for-coding": ModelSpec("Kimi K2.7 Code", "kimi-for-coding", in_picker=True),
-    "kimi-k3": ModelSpec("Kimi K3", "kimi-k3", (3.00, 0.30, 15.00), in_picker=True),
-    "kimi k3": ModelSpec("Kimi K3", "kimi-k3"),
-    "k3": ModelSpec("Kimi K3", "k3", in_picker=True),
-    "k3-256k": ModelSpec("Kimi K3 256K", "k3-256k", in_picker=True),
-    "kimi k3 256k": ModelSpec("Kimi K3 256K", "k3-256k"),
+    "kimi-k2.7-code": ModelSpec("kimi-k2.7-code", "Kimi K2.7 Code", "kimi-k2.7-code", aliases=("kimi k2.7 code",), pricing=(0.95, 0.19, 4.00)),
+    "kimi-for-coding": ModelSpec("kimi-for-coding", "Kimi K2.7 Code", "kimi-for-coding"),
+    "kimi-k3": ModelSpec("kimi-k3", "Kimi K3", "kimi-k3", aliases=("kimi k3",), pricing=(3.00, 0.30, 15.00)),
+    "k3": ModelSpec("k3", "Kimi K3", "k3"),
+    "k3-256k": ModelSpec("k3-256k", "Kimi K3 256K", "k3-256k", aliases=("kimi k3 256k",)),
 }
 
+
+def normalise_served_model(raw_model: str | None) -> ServedModelAttestation:
+    if not raw_model or not raw_model.strip():
+        return ServedModelAttestation.unknown()
+    model_id = raw_model.strip().lower().removeprefix("kimi/")
+    return ServedModelAttestation(
+        raw_model, f"kimi/{model_id}", "exact", "provider-output"
+    )
+
+
+def observe_served_model(event: Mapping[str, Any]) -> str | None:
+    model = event.get("model")
+    if isinstance(model, str) and model.strip():
+        return model
+    message = event.get("message")
+    if isinstance(message, Mapping):
+        model = message.get("model")
+        return model if isinstance(model, str) and model.strip() else None
+    return None
+
 KIMI_LEAD_LAUNCH = LeadLaunchSpec(
     executable="kimi",
     model_flag="--model",
@@ -52,6 +74,7 @@ class KimiExecution:
             stdin_text=None,
             stream_format=STREAM_JSON,
             normalise=content_block_events,
+            observe_served_model=observe_served_model,
             cwd=cwd,
         )
 
@@ -72,9 +95,25 @@ def create_provider() -> ProviderSpec:
             "lead": "kimi-k2.7-code",
             "analyser": "kimi-k2.7-code",
             "critic": "kimi-k3",
+            "designer": "kimi-k2.7-code",
+            "planner": "kimi-k2.7-code",
+            "executor": "kimi-k2.7-code",
+            "verifier": "kimi-k2.7-code",
+            "report-writer": "kimi-k2.7-code",
+            "translator": "kimi-k2.7-code",
         },
         wrapper="okstra-kimi-exec.sh",
-        supported_roles=frozenset({"lead", "analyser", "critic"}),
+        supported_roles=ALL_ROLE_TOKENS,
+        execution_capabilities=frozenset(
+            {
+                "lead-session",
+                "worker-artifact-io",
+                "source-readonly",
+                "extended-artifact-authoring",
+                "project-mutation",
+            }
+        ),
         lead_launch=KIMI_LEAD_LAUNCH,
         exec_strategy=KimiExecution(),
+        served_model_normalizer=normalise_served_model,
     )

package/runtime/python/okstra_ctl/adapters/runtime/__init__.py

@@ -0,0 +1 @@
+"""Execution-surface adapters."""

package/runtime/python/okstra_ctl/adapters/runtime/assembly.py

@@ -0,0 +1,27 @@
+"""Build the injected execution-surface chain for one planned surface."""
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from ...domain.worker_runtime import SURFACE_CLI_WRAPPER, SURFACE_CMUX_PANE
+from ...ports.worker_runtime import WorkerRuntimePort
+from .cli_wrapper import CliWrapperRuntime
+from .cmux import CmuxRuntime
+
+
+def runtime_chain(planned_surface: str) -> tuple[WorkerRuntimePort, ...]:
+    cli = CliWrapperRuntime()
+    if planned_surface == SURFACE_CLI_WRAPPER:
+        return (cli,)
+    if planned_surface == SURFACE_CMUX_PANE:
+        return (CmuxRuntime(), cli)
+    raise ValueError(f"unknown execution surface: {planned_surface}")
+
+
+def port_for(
+    chain: Sequence[WorkerRuntimePort], surface: str
+) -> WorkerRuntimePort:
+    for port in chain:
+        if port.surface == surface:
+            return port
+    raise KeyError(surface)

package/runtime/python/okstra_ctl/adapters/runtime/cli_wrapper.py

@@ -0,0 +1,49 @@
+"""Run a worker as a lead-owned subprocess."""
+from __future__ import annotations
+
+import subprocess
+import uuid
+
+from ...domain.worker_runtime import (
+    SURFACE_CLI_WRAPPER,
+    ProgressEvent,
+    RuntimeHandle,
+    WorkerSpawnRequest,
+)
+
+
+class CliWrapperRuntime:
+    surface = SURFACE_CLI_WRAPPER
+
+    def __init__(self) -> None:
+        self._children: dict[str, subprocess.Popen[str]] = {}
+
+    def spawn(self, request: WorkerSpawnRequest) -> RuntimeHandle:
+        process = subprocess.Popen(
+            list(request.command), cwd=request.cwd, text=True
+        )
+        identifier = uuid.uuid4().hex
+        self._children[identifier] = process
+        return RuntimeHandle(
+            surface=self.surface,
+            identifier=identifier,
+            waitable=True,
+        )
+
+    def close(self, handle: RuntimeHandle) -> None:
+        return None
+
+    def wait(self, handle: RuntimeHandle) -> int:
+        process = self._children[handle.identifier]
+        return process.wait()
+
+    def terminate(self, handle: RuntimeHandle) -> None:
+        process = self._children[handle.identifier]
+        if process.poll() is None:
+            process.terminate()
+
+    def notify(self, event: ProgressEvent) -> None:
+        return None
+
+    def restore_lead(self) -> None:
+        return None

package/runtime/python/okstra_ctl/adapters/runtime/cmux.py

@@ -0,0 +1,74 @@
+"""Open and signal workers on a cmux pane surface."""
+from __future__ import annotations
+
+import subprocess
+
+from ... import cmux
+from ...domain.worker_runtime import (
+    SURFACE_CMUX_PANE,
+    EnvironmentBlocked,
+    ProgressEvent,
+    RuntimeHandle,
+    SurfaceUnavailable,
+    WorkerSpawnRequest,
+)
+
+
+class CmuxRuntime:
+    surface = SURFACE_CMUX_PANE
+
+    def spawn(self, request: WorkerSpawnRequest) -> RuntimeHandle:
+        workspace = cmux.resolve_lead_workspace()
+        if not workspace:
+            reason = cmux.unreachable_reason()
+            if reason in (cmux.LOST_ENVIRONMENT, cmux.LOST_DENIED):
+                observed = (
+                    "this process has no cmux environment left — a sandbox sanitized it"
+                    if reason == cmux.LOST_ENVIRONMENT
+                    else "cmux is running but this process may not connect to its socket"
+                )
+                raise EnvironmentBlocked(
+                    "this run was prepared for cmux panes, but "
+                    f"{observed}. The same sandbox blocks worker CLIs from "
+                    "their own config, so falling back to blocking workers "
+                    "would fail too. Relaunch the lead outside a sandbox "
+                    "(use a full-access lead sandbox)."
+                )
+            raise SurfaceUnavailable("cmux lead workspace is gone")
+        try:
+            surface_id = cmux.spawn_worker_surface(
+                workspace=workspace,
+                cwd=request.cwd,
+                command=request.command,
+                title=request.title,
+                owned_surface_ids=request.owned_surface_ids,
+            )
+        except (RuntimeError, OSError, subprocess.SubprocessError) as exc:
+            raise SurfaceUnavailable(str(exc)) from exc
+        return RuntimeHandle(
+            surface=self.surface,
+            identifier=surface_id,
+            waitable=False,
+        )
+
+    def close(self, handle: RuntimeHandle) -> None:
+        cmux.close_surface(handle.identifier)
+
+    def wait(self, handle: RuntimeHandle) -> int:
+        raise RuntimeError("cmux-pane handles are not waitable")
+
+    def terminate(self, handle: RuntimeHandle) -> None:
+        self.close(handle)
+
+    def notify(self, event: ProgressEvent) -> None:
+        workspace = cmux.resolve_lead_workspace()
+        cmux.sidebar_log(workspace, event.message, level=event.level)
+        if event.notify_title is not None:
+            cmux.sidebar_notify(
+                workspace,
+                title=event.notify_title,
+                body=event.notify_body or "",
+            )
+
+    def restore_lead(self) -> None:
+        cmux.restore_lead_width()

package/runtime/python/okstra_ctl/agent_activity.py

@@ -113,7 +113,11 @@ def _activity_row(event: LeadEvent) -> dict[str, Any]:
         or _ACTIVITY_ID_RE.fullmatch(activity_id) is None
     ):
         raise ActivityProjectionError(f"invalid activityId: {activity_id}")
-    return {key: details[key] for key in ACTIVITY_FIELDS}
+    from okstra_ctl.execution_identity import stored_identity
+
+    row = {key: details[key] for key in ACTIVITY_FIELDS}
+    row.update(stored_identity(details))
+    return row
 
 
 def _validate_activity_order(rows: Sequence[Mapping[str, Any]]) -> None: