@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/runtime_maintenance_context.py

@@ -0,0 +1,309 @@
+"""Runtime installation, update, diagnostics, and upgrade bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from .agy_installer import AgyInstaller
+from .install_diagnostics import InstallDiagnosticsService
+from .package_lifecycle import NpmPackageLifecycle, SelfUpdateLifecycle
+from .runtime_restart import RuntimeRestartService
+from .runtime_upgrade import RuntimeUpgradeService
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimePackagePorts:
+    lifecycle: Callable[[], NpmPackageLifecycle]
+    environment: Mapping[str, str]
+    claude_version: Callable[[str], str]
+    codex_version: Callable[[str], str]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLifecyclePorts:
+    diagnostics: Callable[[], InstallDiagnosticsService]
+    restart: Callable[[], RuntimeRestartService]
+    self_update: Callable[[], SelfUpdateLifecycle]
+    upgrade: Callable[[], RuntimeUpgradeService]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAgyPorts:
+    installer: Callable[[], AgyInstaller]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeUpgradeCommandPorts:
+    ciel_runtime: Callable[[], int]
+    claude: Callable[[], int]
+    codex: Callable[[], int]
+    agy: Callable[[], int]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeMaintenanceContext:
+    packages: RuntimePackagePorts
+    lifecycle: RuntimeLifecyclePorts
+    agy: RuntimeAgyPorts
+    upgrade_commands: RuntimeUpgradeCommandPorts
+
+    def install_runtime_package_if_missing(
+        self,
+        *,
+        executable_name: str,
+        label: str,
+        package_spec: str,
+        skip_env: str,
+    ) -> str | None:
+        return self.packages.lifecycle().install_if_missing(
+            executable_name=executable_name,
+            label=label,
+            package_spec=package_spec,
+            skip_env=skip_env,
+        )
+
+    def run_runtime_npm_update_check(
+        self,
+        executable: str,
+        *,
+        executable_name: str,
+        label: str,
+        package_spec: str,
+        skip_env: str,
+        current_version: Callable[[str], str],
+        enabled: bool = True,
+    ) -> str:
+        return self.packages.lifecycle().update_check(
+            executable,
+            executable_name=executable_name,
+            label=label,
+            package_spec=package_spec,
+            skip_env=skip_env,
+            current_version=current_version,
+            enabled=enabled,
+        )
+
+    def run_claude_update_check(self, executable: str, enabled: bool = True) -> str:
+        package = self.packages.environment.get(
+            "CIEL_RUNTIME_CLAUDE_CODE_PACKAGE", "@anthropic-ai/claude-code@latest"
+        )
+        return self.run_runtime_npm_update_check(
+            executable,
+            executable_name="claude",
+            label="Claude Code",
+            package_spec=package,
+            skip_env="CIEL_RUNTIME_SKIP_CLAUDE_UPDATE",
+            current_version=self.packages.claude_version,
+            enabled=enabled,
+        )
+
+    def run_codex_update_check(self, executable: str, enabled: bool = True) -> str:
+        package = self.packages.environment.get(
+            "CIEL_RUNTIME_CODEX_PACKAGE", "@openai/codex@latest"
+        )
+        return self.run_runtime_npm_update_check(
+            executable,
+            executable_name="codex",
+            label="Codex",
+            package_spec=package,
+            skip_env="CIEL_RUNTIME_SKIP_CODEX_UPDATE",
+            current_version=self.packages.codex_version,
+            enabled=enabled,
+        )
+
+    def install_claude_code_if_missing(self) -> str | None:
+        package = self.packages.environment.get(
+            "CIEL_RUNTIME_CLAUDE_CODE_PACKAGE", "@anthropic-ai/claude-code@latest"
+        )
+        return self.install_runtime_package_if_missing(
+            executable_name="claude",
+            label="Claude Code",
+            package_spec=package,
+            skip_env="CIEL_RUNTIME_SKIP_CLAUDE_INSTALL",
+        )
+
+    def install_codex_if_missing(self) -> str | None:
+        package = self.packages.environment.get(
+            "CIEL_RUNTIME_CODEX_PACKAGE", "@openai/codex@latest"
+        )
+        return self.install_runtime_package_if_missing(
+            executable_name="codex",
+            label="Codex",
+            package_spec=package,
+            skip_env="CIEL_RUNTIME_SKIP_CODEX_INSTALL",
+        )
+
+    def launcher_candidate_dirs(self) -> list[Path]:
+        return self.lifecycle.diagnostics().candidate_dirs()
+
+    def launcher_candidates(self) -> list[Path]:
+        return self.lifecycle.diagnostics().candidates()
+
+    def launcher_version(self, path: Path, timeout: float = 5.0) -> str:
+        return self.lifecycle.diagnostics().launcher_version(path, timeout)
+
+    def install_diagnostics(self) -> list[dict[str, str]]:
+        return self.lifecycle.diagnostics().diagnostics()
+
+    def warn_if_multiple_installs(self) -> None:
+        self.lifecycle.diagnostics().warn_if_multiple()
+
+    def restart_user_args(self) -> list[str]:
+        return self.lifecycle.restart().user_args()
+
+    def restart_after_update(self, npm: str, package_root: Path | None = None) -> None:
+        self.lifecycle.restart().restart(npm, package_root)
+
+    def run_self_update_check(self, enabled: bool = True) -> bool:
+        return self.lifecycle.self_update().run(enabled)
+
+    def quiet_upgrade_ciel_runtime(self) -> int:
+        return self.lifecycle.upgrade().ciel_runtime()
+
+    def quiet_upgrade_claude_code(self) -> int:
+        return self.lifecycle.upgrade().claude()
+
+    def quiet_upgrade_codex(self) -> int:
+        return self.lifecycle.upgrade().codex()
+
+    def quiet_upgrade_agy(self) -> int:
+        return self.lifecycle.upgrade().agy()
+
+    def agy_manifest_name(self) -> str:
+        return self.agy.installer().manifest_name()
+
+    def agy_manifest_url(self) -> str:
+        return self.agy.installer().manifest_url()
+
+    def agy_latest_manifest(self, timeout: float = 15.0) -> dict[str, Any] | None:
+        return self.agy.installer().latest_manifest(timeout)
+
+    def install_agy_from_manifest(self, manifest: dict[str, Any]) -> str | None:
+        return self.agy.installer().install_from_manifest(manifest)
+
+    def install_agy_if_missing(self) -> str | None:
+        return self.agy.installer().install_if_missing()
+
+    def run_agy_update_check(self, executable: str, enabled: bool = True) -> str:
+        return self.agy.installer().update_check(executable, enabled)
+
+    def run_quiet_upgrade_and_exit(self) -> int:
+        results = (
+            self.upgrade_commands.ciel_runtime(),
+            self.upgrade_commands.claude(),
+            self.upgrade_commands.codex(),
+            self.upgrade_commands.agy(),
+        )
+        return 0 if all(result == 0 for result in results) else 1
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeMaintenanceCompatibilityApi:
+    """Late-bound compatibility API for the thin runtime facade."""
+
+    context: Callable[[], RuntimeMaintenanceContext]
+
+    def install_runtime_package_if_missing(self, **options: str) -> str | None:
+        return self.context().install_runtime_package_if_missing(**options)
+
+    def run_runtime_npm_update_check(
+        self,
+        executable: str,
+        *,
+        executable_name: str,
+        label: str,
+        package_spec: str,
+        skip_env: str,
+        current_version: Callable[[str], str],
+        enabled: bool = True,
+    ) -> str:
+        return self.context().run_runtime_npm_update_check(
+            executable,
+            executable_name=executable_name,
+            label=label,
+            package_spec=package_spec,
+            skip_env=skip_env,
+            current_version=current_version,
+            enabled=enabled,
+        )
+
+    def run_claude_update_check(self, executable: str, enabled: bool = True) -> str:
+        return self.context().run_claude_update_check(executable, enabled)
+
+    def run_codex_update_check(self, executable: str, enabled: bool = True) -> str:
+        return self.context().run_codex_update_check(executable, enabled)
+
+    def install_claude_code_if_missing(self) -> str | None:
+        return self.context().install_claude_code_if_missing()
+
+    def install_codex_if_missing(self) -> str | None:
+        return self.context().install_codex_if_missing()
+
+    def launcher_candidate_dirs(self) -> list[Path]:
+        return self.context().launcher_candidate_dirs()
+
+    def launcher_candidates(self) -> list[Path]:
+        return self.context().launcher_candidates()
+
+    def launcher_version(self, path: Path, timeout: float = 5.0) -> str:
+        return self.context().launcher_version(path, timeout)
+
+    def install_diagnostics(self) -> list[dict[str, str]]:
+        return self.context().install_diagnostics()
+
+    def warn_if_multiple_installs(self) -> None:
+        self.context().warn_if_multiple_installs()
+
+    def restart_user_args(self) -> list[str]:
+        return self.context().restart_user_args()
+
+    def restart_after_update(self, npm: str, package_root: Path | None = None) -> None:
+        self.context().restart_after_update(npm, package_root)
+
+    def run_self_update_check(self, enabled: bool = True) -> bool:
+        return self.context().run_self_update_check(enabled)
+
+    def quiet_upgrade_ciel_runtime(self) -> int:
+        return self.context().quiet_upgrade_ciel_runtime()
+
+    def quiet_upgrade_claude_code(self) -> int:
+        return self.context().quiet_upgrade_claude_code()
+
+    def quiet_upgrade_codex(self) -> int:
+        return self.context().quiet_upgrade_codex()
+
+    def quiet_upgrade_agy(self) -> int:
+        return self.context().quiet_upgrade_agy()
+
+    def agy_manifest_name(self) -> str:
+        return self.context().agy_manifest_name()
+
+    def agy_manifest_url(self) -> str:
+        return self.context().agy_manifest_url()
+
+    def agy_latest_manifest(self, timeout: float = 15.0) -> dict[str, Any] | None:
+        return self.context().agy_latest_manifest(timeout)
+
+    def install_agy_from_manifest(self, manifest: dict[str, Any]) -> str | None:
+        return self.context().install_agy_from_manifest(manifest)
+
+    def install_agy_if_missing(self) -> str | None:
+        return self.context().install_agy_if_missing()
+
+    def run_agy_update_check(self, executable: str, enabled: bool = True) -> str:
+        return self.context().run_agy_update_check(executable, enabled)
+
+    def run_quiet_upgrade_and_exit(self) -> int:
+        return self.context().run_quiet_upgrade_and_exit()
+
+
+__all__ = [
+    "RuntimeAgyPorts",
+    "RuntimeLifecyclePorts",
+    "RuntimeMaintenanceCompatibilityApi",
+    "RuntimeMaintenanceContext",
+    "RuntimePackagePorts",
+    "RuntimeUpgradeCommandPorts",
+]

package/ciel_runtime_support/runtime_maintenance_services.py

@@ -0,0 +1,265 @@
+"""Typed service composition for runtime installation and maintenance."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from .agy_installer import AgyInstaller, AgyInstallerPorts
+from .install_diagnostics import (
+    InstallDiagnosticsPorts,
+    InstallDiagnosticsService,
+    InstallDiagnosticsSettings,
+)
+from .package_lifecycle import (
+    NpmPackageLifecycle,
+    NpmPackageLifecyclePorts,
+    SelfUpdateLifecycle,
+    SelfUpdatePorts,
+)
+from .runtime_restart import RuntimeRestartPorts, RuntimeRestartService, RuntimeRestartSettings
+from .runtime_upgrade import (
+    RuntimeUpgradeNpmPorts,
+    RuntimeUpgradeService,
+    RuntimeUpgradeSettings,
+    RuntimeUpgradeToolPorts,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class MaintenanceNpmPorts:
+    find_executable: Callable[[str], str | None]
+    install_command: Callable[..., list[str]]
+    run_upgrade: Callable[..., tuple[int, str]]
+    add_prefix_bin: Callable[[Path], None]
+    latest_version: Callable[..., str | None]
+    version_newer: Callable[[str, str], bool]
+    output: Callable[..., None]
+    current_prefix: Callable[[], Path | None]
+
+
+@dataclass(frozen=True, slots=True)
+class MaintenancePackagePorts:
+    entrypoint: Path
+    environment: Mapping[str, str]
+    package_root: Callable[[Path], Path | None]
+    prefix_from_root: Callable[[Path], Path | None]
+    running_from_package: Callable[[Path, Mapping[str, str]], bool]
+    global_package_root: Callable[..., Path | None]
+    global_install_command: Callable[..., list[str]]
+    current_root: Callable[[], Path | None]
+    running_from_npm: Callable[[], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class MaintenanceDiagnosticPorts:
+    home: Path
+    platform_name: str
+    extra_dirs: Callable[[], list[Path]]
+    parse_version: Callable[[str], tuple[int, ...]]
+    diagnostics: Callable[[], list[dict[str, str]]]
+    stdin_isatty: Callable[[], bool]
+    stdout_isatty: Callable[[], bool]
+    write_error: Callable[[str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class MaintenanceRestartPorts:
+    argv: list[str]
+    executable: str
+    environment: dict[str, str]
+    execv: Callable[..., Any]
+    call: Callable[..., int]
+
+
+@dataclass(frozen=True, slots=True)
+class MaintenanceUpdatePorts:
+    version: str
+    forced_environment: Callable[[], dict[str, str]]
+    restart_after_update: Callable[..., None]
+    claude_version: Callable[[str], str]
+    codex_version: Callable[[str], str]
+    install_claude: Callable[[], str | None]
+    install_codex: Callable[[], str | None]
+    install_agy: Callable[[], str | None]
+    update_agy: Callable[[str, bool], str]
+
+
+@dataclass(frozen=True, slots=True)
+class MaintenanceAgyPorts:
+    manifest_base_url: str
+    user_bin_dir: Callable[[], Path]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeMaintenanceServices:
+    npm: MaintenanceNpmPorts
+    package: MaintenancePackagePorts
+    diagnostics: MaintenanceDiagnosticPorts
+    restart: MaintenanceRestartPorts
+    update: MaintenanceUpdatePorts
+    agy: MaintenanceAgyPorts
+
+    def current_package_root(self) -> Path | None:
+        return self.package.package_root(self.package.entrypoint)
+
+    def current_prefix(self) -> Path | None:
+        root = self.current_package_root()
+        return self.package.prefix_from_root(root) if root else None
+
+    def running_from_npm_package(self) -> bool:
+        return self.package.running_from_package(
+            self.package.entrypoint, self.package.environment
+        )
+
+    def npm_lifecycle(self) -> NpmPackageLifecycle:
+        return NpmPackageLifecycle(
+            NpmPackageLifecyclePorts(
+                self.npm.find_executable,
+                self.npm.current_prefix,
+                self.npm.install_command,
+                self.npm.run_upgrade,
+                self.npm.add_prefix_bin,
+                self.npm.latest_version,
+                self.npm.version_newer,
+                self.npm.output,
+            )
+        )
+
+    def install_diagnostics(self) -> InstallDiagnosticsService:
+        return InstallDiagnosticsService(
+            settings=InstallDiagnosticsSettings(
+                self.diagnostics.home,
+                self.package.environment,
+                self.diagnostics.platform_name == "nt",
+            ),
+            ports=InstallDiagnosticsPorts(
+                extra_dirs=self.diagnostics.extra_dirs,
+                package_root=self.package.package_root,
+                current_root=self.current_package_root,
+                parse_version=self.diagnostics.parse_version,
+                diagnostics=self.diagnostics.diagnostics,
+                stdin_isatty=self.diagnostics.stdin_isatty,
+                stdout_isatty=self.diagnostics.stdout_isatty,
+                write_error=self.diagnostics.write_error,
+            ),
+        )
+
+    def restart_service(self) -> RuntimeRestartService:
+        return RuntimeRestartService(
+            settings=RuntimeRestartSettings(
+                self.restart.argv,
+                self.restart.executable,
+                self.restart.environment,
+                platform_name=self.diagnostics.platform_name,
+            ),
+            ports=RuntimeRestartPorts(
+                current_package_root=self.current_package_root,
+                global_package_root=self.package.global_package_root,
+                find_executable=self.npm.find_executable,
+                execv=self.restart.execv,
+                call=self.restart.call,
+            ),
+        )
+
+    def self_update(self) -> SelfUpdateLifecycle:
+        return SelfUpdateLifecycle(
+            self.update.version,
+            SelfUpdatePorts(
+                self.package.running_from_npm,
+                self.npm.find_executable,
+                self.npm.latest_version,
+                self.npm.version_newer,
+                self.package.current_root,
+                self.package.prefix_from_root,
+                self.package.global_install_command,
+                self.update.forced_environment,
+                self.update.restart_after_update,
+                self.npm.output,
+            ),
+        )
+
+    def upgrade(self) -> RuntimeUpgradeService:
+        return RuntimeUpgradeService(
+            settings=RuntimeUpgradeSettings(
+                self.update.version, self.package.environment
+            ),
+            npm=RuntimeUpgradeNpmPorts(
+                find_executable=self.npm.find_executable,
+                latest_version=self.npm.latest_version,
+                version_newer=self.npm.version_newer,
+                current_package_root=self.package.current_root,
+                package_prefix=self.package.prefix_from_root,
+                current_prefix=self.npm.current_prefix,
+                global_install_command=self.package.global_install_command,
+                runtime_install_command=self.npm.install_command,
+                run_command=self.npm.run_upgrade,
+            ),
+            tools=RuntimeUpgradeToolPorts(
+                claude_version=self.update.claude_version,
+                codex_version=self.update.codex_version,
+                install_claude=self.update.install_claude,
+                install_codex=self.update.install_codex,
+                install_agy=self.update.install_agy,
+                update_agy=self.update.update_agy,
+            ),
+            output=lambda message: self.npm.output(message, flush=True),
+        )
+
+    def agy_installer(self) -> AgyInstaller:
+        return AgyInstaller(
+            self.agy.manifest_base_url,
+            AgyInstallerPorts(
+                self.agy.user_bin_dir,
+                self.update.forced_environment,
+                self.npm.find_executable,
+                self.npm.version_newer,
+                self.npm.run_upgrade,
+                self.npm.output,
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeMaintenanceServicesCompatibilityApi:
+    services: Callable[[], RuntimeMaintenanceServices]
+
+    def npm_lifecycle(self) -> NpmPackageLifecycle:
+        return self.services().npm_lifecycle()
+
+    def current_prefix(self) -> Path | None:
+        return self.services().current_prefix()
+
+    def running_from_npm_package(self) -> bool:
+        return self.services().running_from_npm_package()
+
+    def current_package_root(self) -> Path | None:
+        return self.services().current_package_root()
+
+    def install_diagnostics(self) -> InstallDiagnosticsService:
+        return self.services().install_diagnostics()
+
+    def restart_service(self) -> RuntimeRestartService:
+        return self.services().restart_service()
+
+    def self_update(self) -> SelfUpdateLifecycle:
+        return self.services().self_update()
+
+    def upgrade(self) -> RuntimeUpgradeService:
+        return self.services().upgrade()
+
+    def agy_installer(self) -> AgyInstaller:
+        return self.services().agy_installer()
+
+
+__all__ = [
+    "MaintenanceAgyPorts",
+    "MaintenanceDiagnosticPorts",
+    "MaintenanceNpmPorts",
+    "MaintenancePackagePorts",
+    "MaintenanceRestartPorts",
+    "MaintenanceUpdatePorts",
+    "RuntimeMaintenanceServices",
+    "RuntimeMaintenanceServicesCompatibilityApi",
+]

package/ciel_runtime_support/runtime_paths.py

@@ -9,6 +9,7 @@ from pathlib import Path, PureWindowsPath
 from typing import Any
 
 from .web_endpoints import apply_startup_web_options, load_saved_web_backend
+from .workspace_router_selection import select_workspace_router_port, workspace_identity
 
 
 # Web startup flags affect the process-wide router endpoint constants below.
@@ -96,52 +97,71 @@ def default_router_port(saved_port: int = 0) -> int:
 
 CONFIG_DIR = Path(os.environ.get("CIEL_RUNTIME_CONFIG_DIR") or platform_config_dir("ciel-runtime"))
 CONFIG_PATH = CONFIG_DIR / "config.json"
-LOG_PATH = CONFIG_DIR / "router.log"
-LOG_LEVEL_PATH = CONFIG_DIR / "log-level"
-REQUEST_DUMP_PATH = CONFIG_DIR / "requests.jsonl"
-RESPONSE_DUMP_PATH = CONFIG_DIR / "responses.jsonl"
-USAGE_EVENTS_PATH = CONFIG_DIR / "usage-events.jsonl"
-SSE_TRACE_PATH = CONFIG_DIR / "router-sse-trace.jsonl"
-SSE_LAST_PATH = CONFIG_DIR / "router-last-sse.json"
-TOOL_CALL_LOG_PATH = CONFIG_DIR / "tool-calls.jsonl"
-RATE_LIMIT_STATE_PATH = CONFIG_DIR / "rate-limit-state.json"
-ROUTER_ACTIVITY_PATH = CONFIG_DIR / "router-activity.json"
-CONTEXT_COMPACT_ACTIVITY_PATH = CONFIG_DIR / "context-compact-activity.json"
-CONTEXT_USAGE_PATH = CONFIG_DIR / "context-usage.json"
-OLLAMA_MODEL_CATALOG_PATH = CONFIG_DIR / "ollama-model-catalog.json"
-CHAT_MESSAGES_PATH = CONFIG_DIR / "chat-messages.jsonl"
-CHAT_FILES_DIR = CONFIG_DIR / "chat-files"
-MENU_KEY_DEBUG_PATH = CONFIG_DIR / "ca-key-debug.log"
-PLAN_ARTIFACTS_DIR = CONFIG_DIR / "plan-artifacts"
-PID_PATH = CONFIG_DIR / "router.pid"
-ROUTER_EXTERNAL_TOKEN_PATH = CONFIG_DIR / "router-external-token"
-ROUTER_CLIENTS_DIR = CONFIG_DIR / "router-clients"
-MODEL_LIST_CACHE_PATH = CONFIG_DIR / "model-list-cache.json"
-MODEL_REGISTRY_PATH = CONFIG_DIR / "model-registry.json"
-LAUNCH_STATE_PATH = CONFIG_DIR / "launch-state.json"
-WEB_TOOLS_MCP_CONFIG = CONFIG_DIR / "web-tools-mcp.json"
-DUCKDUCKGO_MCP_CONFIG = CONFIG_DIR / "duckduckgo-mcp.json"
-ZAI_MCP_CONFIG = CONFIG_DIR / "zai-mcp.json"
-CHANNEL_MCP_CONFIG = CONFIG_DIR / "channel-mcp.json"
-NATIVE_MCP_CONFIG = CONFIG_DIR / "native-mcp.json"
-CODEX_MCP_CONFIG = CONFIG_DIR / "codex-mcp.json"
-CODEX_PROCESS_DIR = CONFIG_DIR / "codex-processes"
-CODEX_PROMPTS_DIR_NAME = "prompts"
-CHANNEL_MCP_CURSOR_PATH = CONFIG_DIR / "channel-mcp-cursor.json"
-CHANNEL_LLM_CURSOR_PATH = CONFIG_DIR / "channel-llm-cursor.json"
-CHANNEL_LLM_CLEAR_FLOOR_PATH = CONFIG_DIR / "channel-llm-clear-floor.json"
-CHANNEL_LLM_LAUNCH_GUARD_PATH = CONFIG_DIR / "channel-llm-launch-guard.json"
-CHANNEL_COMPACT_REQUEST_PATH = CONFIG_DIR / "channel-compact-request.json"
-CHANNEL_STDIN_WAKE_CLAIMS_PATH = CONFIG_DIR / "channel-stdin-wake-claims.json"
-CHANNEL_PROBE_CACHE_PATH = CONFIG_DIR / "channel-probe-cache.json"
-MCP_PROXY_CONFIG = CONFIG_DIR / "mcp-proxy.json"
 _SAVED_WEB_BACKEND = load_saved_web_backend(CONFIG_PATH)
 ROUTER_HOST = (
     os.environ.get("CIEL_RUNTIME_ROUTER_CLIENT_HOST", "").strip()
     or _SAVED_WEB_BACKEND.client_host
 )
-ROUTER_PORT = default_router_port(_SAVED_WEB_BACKEND.port)
+_BASE_ROUTER_PORT = default_router_port(_SAVED_WEB_BACKEND.port)
+ROUTER_PORT = select_workspace_router_port(_BASE_ROUTER_PORT, Path.cwd(), os.environ)
 ROUTER_BASE = f"http://{ROUTER_HOST}:{ROUTER_PORT}"
+ROUTER_WORKSPACE = workspace_identity(
+    os.environ.get("CIEL_RUNTIME_LAUNCH_CWD") or Path.cwd()
+)
+_WORKSPACE_DIGEST = hashlib.sha256(ROUTER_WORKSPACE.encode("utf-8", errors="replace")).hexdigest()[:12]
+_STATE_DIR_OVERRIDE = str(os.environ.get("CIEL_RUNTIME_STATE_DIR") or "").strip()
+_TEST_STATE_ISOLATED = str(os.environ.get("CIEL_RUNTIME_TEST_ISOLATED") or "").strip().lower() in {
+    "1",
+    "true",
+    "yes",
+    "on",
+}
+ROUTER_INSTANCE_DIR = (
+    Path(_STATE_DIR_OVERRIDE)
+    if _STATE_DIR_OVERRIDE
+    else CONFIG_DIR
+    if _TEST_STATE_ISOLATED
+    else CONFIG_DIR / "router-instances" / f"{ROUTER_PORT}-{_WORKSPACE_DIGEST}"
+)
+LOG_PATH = ROUTER_INSTANCE_DIR / "router.log"
+LOG_LEVEL_PATH = CONFIG_DIR / "log-level"
+REQUEST_DUMP_PATH = ROUTER_INSTANCE_DIR / "requests.jsonl"
+RESPONSE_DUMP_PATH = ROUTER_INSTANCE_DIR / "responses.jsonl"
+USAGE_EVENTS_PATH = ROUTER_INSTANCE_DIR / "usage-events.jsonl"
+SSE_TRACE_PATH = ROUTER_INSTANCE_DIR / "router-sse-trace.jsonl"
+SSE_LAST_PATH = ROUTER_INSTANCE_DIR / "router-last-sse.json"
+TOOL_CALL_LOG_PATH = ROUTER_INSTANCE_DIR / "tool-calls.jsonl"
+RATE_LIMIT_STATE_PATH = ROUTER_INSTANCE_DIR / "rate-limit-state.json"
+ROUTER_ACTIVITY_PATH = ROUTER_INSTANCE_DIR / "router-activity.json"
+CONTEXT_COMPACT_ACTIVITY_PATH = ROUTER_INSTANCE_DIR / "context-compact-activity.json"
+CONTEXT_USAGE_PATH = ROUTER_INSTANCE_DIR / "context-usage.json"
+OLLAMA_MODEL_CATALOG_PATH = CONFIG_DIR / "ollama-model-catalog.json"
+CHAT_MESSAGES_PATH = ROUTER_INSTANCE_DIR / "chat-messages.jsonl"
+CHAT_FILES_DIR = ROUTER_INSTANCE_DIR / "chat-files"
+MENU_KEY_DEBUG_PATH = ROUTER_INSTANCE_DIR / "ca-key-debug.log"
+PLAN_ARTIFACTS_DIR = ROUTER_INSTANCE_DIR / "plan-artifacts"
+PID_PATH = ROUTER_INSTANCE_DIR / "router.pid"
+ROUTER_EXTERNAL_TOKEN_PATH = ROUTER_INSTANCE_DIR / "router-external-token"
+ROUTER_CLIENTS_DIR = ROUTER_INSTANCE_DIR / "router-clients"
+MODEL_LIST_CACHE_PATH = CONFIG_DIR / "model-list-cache.json"
+MODEL_REGISTRY_PATH = CONFIG_DIR / "model-registry.json"
+LAUNCH_STATE_PATH = CONFIG_DIR / "launch-state.json"
+WEB_TOOLS_MCP_CONFIG = ROUTER_INSTANCE_DIR / "web-tools-mcp.json"
+DUCKDUCKGO_MCP_CONFIG = ROUTER_INSTANCE_DIR / "duckduckgo-mcp.json"
+ZAI_MCP_CONFIG = ROUTER_INSTANCE_DIR / "zai-mcp.json"
+CHANNEL_MCP_CONFIG = ROUTER_INSTANCE_DIR / "channel-mcp.json"
+NATIVE_MCP_CONFIG = ROUTER_INSTANCE_DIR / "native-mcp.json"
+CODEX_MCP_CONFIG = ROUTER_INSTANCE_DIR / "codex-mcp.json"
+CODEX_PROCESS_DIR = ROUTER_INSTANCE_DIR / "codex-processes"
+CODEX_PROMPTS_DIR_NAME = "prompts"
+CHANNEL_MCP_CURSOR_PATH = ROUTER_INSTANCE_DIR / "channel-mcp-cursor.json"
+CHANNEL_LLM_CURSOR_PATH = ROUTER_INSTANCE_DIR / "channel-llm-cursor.json"
+CHANNEL_LLM_CLEAR_FLOOR_PATH = ROUTER_INSTANCE_DIR / "channel-llm-clear-floor.json"
+CHANNEL_LLM_LAUNCH_GUARD_PATH = ROUTER_INSTANCE_DIR / "channel-llm-launch-guard.json"
+CHANNEL_COMPACT_REQUEST_PATH = ROUTER_INSTANCE_DIR / "channel-compact-request.json"
+CHANNEL_STDIN_WAKE_CLAIMS_PATH = ROUTER_INSTANCE_DIR / "channel-stdin-wake-claims.json"
+CHANNEL_PROBE_CACHE_PATH = ROUTER_INSTANCE_DIR / "channel-probe-cache.json"
+MCP_PROXY_CONFIG = ROUTER_INSTANCE_DIR / "mcp-proxy.json"
 CLAUDE_GATEWAY_CACHE = HOME / ".claude" / "cache" / "gateway-models.json"
 CLAUDE_SETTINGS_PATH = HOME / ".claude" / "settings.json"
 CLAUDE_COMMANDS_DIR = HOME / ".claude" / "commands"