@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/runtime_asset_context.py

@@ -0,0 +1,297 @@
+"""Executable discovery and runtime-owned command asset installation context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from .command_asset_installer import CommandAsset, CommandAssetInstaller
+from .executable_discovery import ExecutableDiscovery
+from .statusline_settings import StatusLineServices, install_statusline_settings
+from .tool_guard_hooks import (
+    LegacyToolGuardShimInstaller,
+    LegacyToolGuardShimServices,
+    ToolGuardHookServices,
+    install_tool_guard_hook_settings,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeExecutablePaths:
+    home: Path
+    source_file: Path
+    platform_path: Callable[[], str]
+    runtime_bin_dir: Callable[[], Path]
+    agy_bin_dir: Callable[[], Path]
+    python_executable: str
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAssetPaths:
+    package_root: Path
+    statusline_path: Path
+    statusline_script: Path
+    claude_commands_dir: Path
+    codex_prompts_dir_name: str
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAssetEffects:
+    settings_repository: Callable[[], Any]
+    chmod: Callable[[Path, int], None]
+    log: Callable[[str, str], None]
+    warn: Callable[[str], None]
+    environ: Mapping[str, str]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeCommandAssetCatalog:
+    standard: dict[str, CommandAsset]
+    advisor: CommandAsset
+    advisor_markers: tuple[str, ...]
+    import_session: CommandAsset
+    import_markers: tuple[str, ...]
+    stale_markers: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeToolGuardPolicy:
+    default_hook_policy: Any
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAssetCompatibilityPorts:
+    find_executable: Callable[[str], str | None]
+    find_tool_guard: Callable[[], Path | None]
+    tool_guard_command: Callable[[], str | None]
+    install_legacy_shim: Callable[[], None]
+    command_asset_installer: Callable[[Path], CommandAssetInstaller]
+    remove_advisor_command: Callable[[], None]
+    codex_prompts_dir: Callable[[Mapping[str, str] | None], Path]
+    command_assets: Callable[[bool], dict[str, CommandAsset]]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAssetContext:
+    executable: RuntimeExecutablePaths
+    paths: RuntimeAssetPaths
+    effects: RuntimeAssetEffects
+    catalog: RuntimeCommandAssetCatalog
+    tool_guard: RuntimeToolGuardPolicy
+    compatibility: RuntimeAssetCompatibilityPorts
+
+    def executable_discovery(self) -> ExecutableDiscovery:
+        return ExecutableDiscovery(
+            self.executable.home,
+            self.executable.source_file,
+            self.executable.platform_path,
+            self.executable.runtime_bin_dir,
+            self.executable.agy_bin_dir,
+        )
+
+    def executable_extra_dirs(self) -> list[Path]:
+        return self.executable_discovery().extra_dirs()
+
+    def find_executable(self, name: str) -> str | None:
+        return self.executable_discovery().find(name)
+
+    def resolve_executable(self, command: str) -> str:
+        return self.executable_discovery().resolve(command)
+
+    def resolve_mcp_process(
+        self, command: str, args: list[str]
+    ) -> tuple[str, list[str]]:
+        return self.executable_discovery().resolve_mcp_process(
+            command, args, self.compatibility.find_executable
+        )
+
+    @staticmethod
+    def shell_command(args: list[str]) -> str:
+        return ExecutableDiscovery.shell_command(args)
+
+    def find_tool_guard(self) -> Path | None:
+        return self.executable_discovery().find_tool_guard(self.find_executable)
+
+    def tool_guard_command(self) -> str | None:
+        script = self.compatibility.find_tool_guard()
+        if script is None:
+            return None
+        command = (
+            [self.executable.python_executable, str(script)]
+            if script.suffix == ".py"
+            else [str(script)]
+        )
+        return self.shell_command(command)
+
+    def install_legacy_tool_guard_shim(self) -> None:
+        LegacyToolGuardShimInstaller(
+            LegacyToolGuardShimServices(
+                package_root=self.paths.package_root,
+                find_target=self.compatibility.find_tool_guard,
+                chmod=self.effects.chmod,
+                log=self.effects.log,
+            )
+        ).install()
+
+    def install_tool_guard_hooks(self) -> None:
+        install_tool_guard_hook_settings(
+            self.compatibility.tool_guard_command(),
+            self.tool_guard.default_hook_policy,
+            ToolGuardHookServices(
+                repository=self.effects.settings_repository(),
+                install_legacy_shim=self.compatibility.install_legacy_shim,
+                warn=self.effects.warn,
+            ),
+        )
+
+    def install_statusline(self) -> None:
+        install_statusline_settings(
+            self.paths.statusline_path,
+            self.paths.statusline_script,
+            self.executable.python_executable,
+            StatusLineServices(
+                repository=self.effects.settings_repository(),
+                warn=self.effects.warn,
+            ),
+        )
+
+    def command_asset_installer(self, directory: Path) -> CommandAssetInstaller:
+        return CommandAssetInstaller(directory, self.effects.warn)
+
+    def remove_advisor_command(self) -> None:
+        self.compatibility.command_asset_installer(
+            self.paths.claude_commands_dir
+        ).remove_one(
+            "advisor.md", self.catalog.advisor_markers
+        )
+
+    def codex_prompts_dir(
+        self, env: Mapping[str, str] | None = None
+    ) -> Path:
+        environment = env or self.effects.environ
+        raw_home = environment.get("CODEX_HOME")
+        home = (
+            Path(raw_home).expanduser()
+            if raw_home
+            else self.executable.home / ".codex"
+        )
+        return home / self.paths.codex_prompts_dir_name
+
+    def install_codex_prompts(
+        self, env: Mapping[str, str] | None = None
+    ) -> None:
+        self.compatibility.command_asset_installer(
+            self.compatibility.codex_prompts_dir(env)
+        ).install_one(
+            "ImportSession.md", self.catalog.import_session
+        )
+
+    def disable_codex_prompts(
+        self, env: Mapping[str, str] | None = None
+    ) -> None:
+        self.compatibility.command_asset_installer(
+            self.compatibility.codex_prompts_dir(env)
+        ).remove_one(
+            "ImportSession.md", self.catalog.import_markers
+        )
+
+    def command_assets(self, include_advisor: bool = True) -> dict[str, CommandAsset]:
+        assets = dict(self.catalog.standard)
+        if include_advisor:
+            assets["advisor.md"] = self.catalog.advisor
+        return assets
+
+    def install_slash_commands(self, include_advisor: bool = True) -> None:
+        if not include_advisor:
+            self.compatibility.remove_advisor_command()
+        self.compatibility.command_asset_installer(
+            self.paths.claude_commands_dir
+        ).install_all(
+            self.compatibility.command_assets(include_advisor),
+            stale_glob="llm-*.md",
+            stale_markers=self.catalog.stale_markers,
+        )
+
+    def disable_slash_commands(self) -> None:
+        self.compatibility.command_asset_installer(
+            self.paths.claude_commands_dir
+        ).remove_all(
+            self.compatibility.command_assets(True),
+            stale_glob="llm-*.md",
+            stale_markers=self.catalog.stale_markers,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAssetCompatibilityApi:
+    context: Callable[[], RuntimeAssetContext]
+
+    def executable_discovery(self) -> ExecutableDiscovery:
+        return self.context().executable_discovery()
+
+    def executable_extra_dirs(self) -> list[Path]:
+        return self.context().executable_extra_dirs()
+
+    def find_executable(self, name: str) -> str | None:
+        return self.context().find_executable(name)
+
+    def resolve_executable(self, command: str) -> str:
+        return self.context().resolve_executable(command)
+
+    def resolve_mcp_process(self, *args: Any, **kwargs: Any) -> tuple[str, list[str]]:
+        return self.context().resolve_mcp_process(*args, **kwargs)
+
+    def shell_command(self, args: list[str]) -> str:
+        return self.context().shell_command(args)
+
+    def find_tool_guard(self) -> Path | None:
+        return self.context().find_tool_guard()
+
+    def tool_guard_command(self) -> str | None:
+        return self.context().tool_guard_command()
+
+    def install_legacy_tool_guard_shim(self) -> None:
+        self.context().install_legacy_tool_guard_shim()
+
+    def install_tool_guard_hooks(self) -> None:
+        self.context().install_tool_guard_hooks()
+
+    def install_statusline(self) -> None:
+        self.context().install_statusline()
+
+    def command_asset_installer(self, directory: Path) -> CommandAssetInstaller:
+        return self.context().command_asset_installer(directory)
+
+    def remove_advisor_command(self) -> None:
+        self.context().remove_advisor_command()
+
+    def codex_prompts_dir(self, *args: Any, **kwargs: Any) -> Path:
+        return self.context().codex_prompts_dir(*args, **kwargs)
+
+    def install_codex_prompts(self, *args: Any, **kwargs: Any) -> None:
+        self.context().install_codex_prompts(*args, **kwargs)
+
+    def disable_codex_prompts(self, *args: Any, **kwargs: Any) -> None:
+        self.context().disable_codex_prompts(*args, **kwargs)
+
+    def command_assets(self, include_advisor: bool = True) -> dict[str, CommandAsset]:
+        return self.context().command_assets(include_advisor)
+
+    def install_slash_commands(self, include_advisor: bool = True) -> None:
+        self.context().install_slash_commands(include_advisor)
+
+    def disable_slash_commands(self) -> None:
+        self.context().disable_slash_commands()
+
+
+__all__ = [
+    "RuntimeAssetCompatibilityApi",
+    "RuntimeAssetCompatibilityPorts",
+    "RuntimeAssetContext",
+    "RuntimeAssetEffects",
+    "RuntimeAssetPaths",
+    "RuntimeCommandAssetCatalog",
+    "RuntimeExecutablePaths",
+    "RuntimeToolGuardPolicy",
+]

package/ciel_runtime_support/runtime_constants.py

@@ -93,7 +93,7 @@ OFFICIAL_CHANNEL_PLUGINS = {
 }
 
 APP_NAME = "Ciel Runtime"
-VERSION = "0.2.2"
+VERSION = "0.2.4"
 CREDITS = "Credits: One Ciel LLC"
 PRELAUNCH_CANCEL = 10
 PRELAUNCH_LAUNCH_CODEX = 11
@@ -159,6 +159,21 @@ ROUTED_COMPAT_PROMPT = (
     "or report the concrete connection state. Never write pseudo tool calls, partial JSON, or markdown code fences when a real Claude Code tool call is required."
 )
 NON_ANTHROPIC_COMPAT_PROMPT = ROUTED_COMPAT_PROMPT
+# ROUTED_COMPAT_PROMPT is Claude Code specific -- it names Claude Code tools and
+# is delivered with --append-system-prompt, a flag Codex classifies as Claude-only.
+# Routed Codex sessions therefore had no equivalent instruction and would end a
+# turn right after announcing what they were about to do. This is the Codex
+# wording, appended to the Responses `instructions` field instead of a CLI flag.
+# Keep it constant: it sits at the head of the prompt, so any variation would
+# invalidate the upstream prefix cache on every turn.
+ROUTED_CODEX_COMPAT_PROMPT = (
+    "You are running inside Codex CLI through the ciel-runtime router. Do not stop after announcing what you plan to do. "
+    "When the user asks you to inspect, create, edit, or run code, call the tools available in this turn and report the concrete result. "
+    "Never end a turn with only a statement of intent such as saying you will now start; perform the work in the same turn. "
+    "If the task has several reasonable in-scope parts, do all of them; do not ask which part to start unless the user explicitly asked for a choice. "
+    "If you decide not to use tools, give the complete answer in the same turn. "
+    "Use exactly the tool schema provided and do not invent extra fields, and never write pseudo tool calls or partial JSON where a real tool call is required."
+)
 LANGUAGES = {"en": "English", "ko": "한국어", "ja": "日本語", "zh": "中文"}
 MODEL_PRESETS: dict[str, dict[str, Any]] = {
     "deepseek-v4-flash:0731": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},

package/ciel_runtime_support/runtime_launch.py

@@ -18,7 +18,7 @@ from ciel_runtime_support.runtime_constants import (
     PRELAUNCH_LAUNCH_CODEX_APP_SERVER,
     ROUTED_COMPAT_PROMPT,
 )
-from ciel_runtime_support.runtime_paths import CONFIG_DIR, LOG_PATH
+from ciel_runtime_support.runtime_paths import CONFIG_DIR, LOG_PATH, ROUTER_INSTANCE_DIR
 from ciel_runtime_support.web_endpoints import web_backend_settings
 
 
@@ -160,7 +160,6 @@ class ClaudeLaunchChannelDelivery:
     claude_channel_args: Callable[..., Any]
     native_channel_passthrough_requested: Callable[..., Any]
     normalize_channel_passthrough: Callable[..., Any]
-    prepare_channel_llm_delivery_for_launch: Callable[..., Any]
     should_launch_process_start_channel_sse: Callable[..., Any]
     should_use_channel_llm_delivery: Callable[..., Any]
     should_use_channel_stdin_proxy: Callable[..., Any]
@@ -255,7 +254,6 @@ def run_claude(
     native_channel_passthrough_requested = services.channel_delivery.native_channel_passthrough_requested
     normalize_channel_passthrough = services.channel_delivery.normalize_channel_passthrough
     path_with_ciel_runtime_user_dirs = services.process.path_with_ciel_runtime_user_dirs
-    prepare_channel_llm_delivery_for_launch = services.channel_delivery.prepare_channel_llm_delivery_for_launch
     print_routed_claude_exit_diagnostics = services.process.print_routed_claude_exit_diagnostics
     provider_menu_label = services.config.provider_menu_label
     read_channel_probe_cache = services.channel_discovery.read_channel_probe_cache
@@ -347,6 +345,9 @@ def run_claude(
     )
     cleanup_managed_services_for_provider(provider, pcfg, cfg, quiet=True)
     env = os.environ.copy()
+    env["CIEL_RUNTIME_CONFIG_DIR"] = str(CONFIG_DIR)
+    env["CIEL_RUNTIME_STATE_DIR"] = str(ROUTER_INSTANCE_DIR)
+    env["CIEL_RUNTIME_LAUNCH_CWD"] = str(Path.cwd())
     env["PATH"] = path_with_ciel_runtime_user_dirs(env)
     launch_passthrough = normalize_channel_passthrough(passthrough)
     native_channel_bridge = should_use_native_channel_bridge(use_router_mode, cfg, launch_passthrough)
@@ -513,8 +514,6 @@ def run_claude(
             mcp_config_paths.extend(native_direct_mcp_config_paths)
             claude_passthrough = strip_mcp_config_passthrough(launch_passthrough)
     elif stdin_channel_proxy or llm_channel_delivery or native_auto_channel_specs:
-        if llm_channel_delivery:
-            prepare_channel_llm_delivery_for_launch()
         if should_launch_process_start_channel_sse(stdin_channel_proxy, native_channel_bridge, llm_channel_delivery):
             auto_start_sse_channels_from_mcp_configs(
                 launch_passthrough,
@@ -829,6 +828,7 @@ def run_codex(
     warn_if_multiple_ciel_runtime_installs()
     run_ciel_runtime_update_check(enabled=self_update_check)
     env = os.environ.copy()
+    env["CIEL_RUNTIME_STATE_DIR"] = str(ROUTER_INSTANCE_DIR)
     env["PATH"] = path_with_ciel_runtime_user_dirs(env)
     codex = install_codex_if_missing()
     if not codex:
@@ -1172,6 +1172,7 @@ def run_codex_app_server(
     warn_if_multiple_ciel_runtime_installs()
     run_ciel_runtime_update_check(enabled=self_update_check)
     env = os.environ.copy()
+    env["CIEL_RUNTIME_STATE_DIR"] = str(ROUTER_INSTANCE_DIR)
     env["PATH"] = path_with_ciel_runtime_user_dirs(env)
     codex = install_codex_if_missing()
     if not codex:
@@ -1453,6 +1454,9 @@ def run_agy(
     warn_if_multiple_ciel_runtime_installs()
     run_ciel_runtime_update_check(enabled=self_update_check)
     env = os.environ.copy()
+    env["CIEL_RUNTIME_CONFIG_DIR"] = str(CONFIG_DIR)
+    env["CIEL_RUNTIME_STATE_DIR"] = str(ROUTER_INSTANCE_DIR)
+    env["CIEL_RUNTIME_LAUNCH_CWD"] = str(Path.cwd())
     env["PATH"] = path_with_ciel_runtime_user_dirs(env)
     agy = install_agy_if_missing()
     if not agy:

package/ciel_runtime_support/runtime_launch_context.py

@@ -0,0 +1,130 @@
+"""Runtime launch dispatch context with explicitly supplied service factories."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from .runtime_launch import (
+    AgyLaunchServices,
+    ClaudeLaunchServices,
+    CodexAppServerLaunchServices,
+    CodexLaunchServices,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLaunchRunners:
+    claude: Callable[..., int]
+    codex: Callable[..., int]
+    codex_app_server: Callable[..., int]
+    agy: Callable[..., int]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLaunchServiceFactories:
+    claude: Callable[[], ClaudeLaunchServices]
+    codex: Callable[[], CodexLaunchServices]
+    codex_app_server: Callable[[], CodexAppServerLaunchServices]
+    agy: Callable[[], AgyLaunchServices]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLaunchContext:
+    runners: RuntimeLaunchRunners
+    services: RuntimeLaunchServiceFactories
+
+    def launch_claude(
+        self,
+        passthrough: list[str],
+        skip_menu: bool = False,
+        force_menu: bool = False,
+        web_search_override: bool | None = None,
+        update_check: bool = True,
+        self_update_check: bool = True,
+    ) -> int:
+        return self.runners.claude(
+            passthrough,
+            skip_menu=skip_menu,
+            force_menu=force_menu,
+            web_search_override=web_search_override,
+            update_check=update_check,
+            self_update_check=self_update_check,
+            services=self.services.claude(),
+        )
+
+    def launch_codex(
+        self,
+        passthrough: list[str],
+        skip_menu: bool = False,
+        force_menu: bool = False,
+        update_check: bool = True,
+        self_update_check: bool = True,
+    ) -> int:
+        return self.runners.codex(
+            passthrough,
+            skip_menu=skip_menu,
+            force_menu=force_menu,
+            update_check=update_check,
+            self_update_check=self_update_check,
+            services=self.services.codex(),
+        )
+
+    def launch_codex_app_server(
+        self,
+        passthrough: list[str],
+        skip_menu: bool = True,
+        force_menu: bool = False,
+        update_check: bool = True,
+        self_update_check: bool = True,
+    ) -> int:
+        return self.runners.codex_app_server(
+            passthrough,
+            skip_menu=skip_menu,
+            force_menu=force_menu,
+            update_check=update_check,
+            self_update_check=self_update_check,
+            services=self.services.codex_app_server(),
+        )
+
+    def launch_agy(
+        self,
+        passthrough: list[str],
+        skip_menu: bool = False,
+        force_menu: bool = False,
+        update_check: bool = True,
+        self_update_check: bool = True,
+    ) -> int:
+        return self.runners.agy(
+            passthrough,
+            skip_menu=skip_menu,
+            force_menu=force_menu,
+            update_check=update_check,
+            self_update_check=self_update_check,
+            services=self.services.agy(),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLaunchCompatibilityApi:
+    context: Callable[[], RuntimeLaunchContext]
+
+    def launch_claude(self, *args: Any, **kwargs: Any) -> int:
+        return self.context().launch_claude(*args, **kwargs)
+
+    def launch_codex(self, *args: Any, **kwargs: Any) -> int:
+        return self.context().launch_codex(*args, **kwargs)
+
+    def launch_codex_app_server(self, *args: Any, **kwargs: Any) -> int:
+        return self.context().launch_codex_app_server(*args, **kwargs)
+
+    def launch_agy(self, *args: Any, **kwargs: Any) -> int:
+        return self.context().launch_agy(*args, **kwargs)
+
+
+__all__ = [
+    "RuntimeLaunchCompatibilityApi",
+    "RuntimeLaunchContext",
+    "RuntimeLaunchRunners",
+    "RuntimeLaunchServiceFactories",
+]

package/ciel_runtime_support/runtime_maintenance_assembly.py

@@ -0,0 +1,60 @@
+"""Composition boundary for runtime installation and maintenance services."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Mapping
+
+from .runtime_maintenance_context import (
+    RuntimeAgyPorts,
+    RuntimeLifecyclePorts,
+    RuntimeMaintenanceContext,
+    RuntimePackagePorts,
+    RuntimeUpgradeCommandPorts,
+)
+from .runtime_maintenance_services import RuntimeMaintenanceServices
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeMaintenanceCommandPorts:
+    environment: Mapping[str, str]
+    claude_version: Callable[[str], str]
+    codex_version: Callable[[str], str]
+    upgrade_runtime: Callable[[], int]
+    upgrade_claude: Callable[[], int]
+    upgrade_codex: Callable[[], int]
+    upgrade_agy: Callable[[], int]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeMaintenanceAssembly:
+    service_graph: RuntimeMaintenanceServices
+    commands: RuntimeMaintenanceCommandPorts
+
+    def context(self) -> RuntimeMaintenanceContext:
+        services = self.service_graph
+        commands = self.commands
+        return RuntimeMaintenanceContext(
+            packages=RuntimePackagePorts(
+                services.npm_lifecycle,
+                commands.environment,
+                commands.claude_version,
+                commands.codex_version,
+            ),
+            lifecycle=RuntimeLifecyclePorts(
+                services.install_diagnostics,
+                services.restart_service,
+                services.self_update,
+                services.upgrade,
+            ),
+            agy=RuntimeAgyPorts(services.agy_installer),
+            upgrade_commands=RuntimeUpgradeCommandPorts(
+                commands.upgrade_runtime,
+                commands.upgrade_claude,
+                commands.upgrade_codex,
+                commands.upgrade_agy,
+            ),
+        )
+
+
+__all__ = ["RuntimeMaintenanceAssembly", "RuntimeMaintenanceCommandPorts"]