clm-kernel 0.0.0__py3-none-any.whl

clm/layer4/_sovereign_executor.py

@@ -0,0 +1,580 @@
+import contextlib
+import json
+import os
+import subprocess
+import sys
+
+if sys.platform == "win32":
+    git_bin = r"C:\Program Files\Git\bin"
+    if os.path.exists(git_bin) and git_bin not in os.environ.get("PATH", ""):
+        os.environ["PATH"] = git_bin + os.pathsep + os.environ.get("PATH", "")
+
+from clm.cross_cutting.clm_logger import get_logger
+from clm.cross_cutting.pcard import run_balanced_expectations
+from clm.layer0.utils import clm_hash_file, get_bash_command, resolve_clm_path
+from clm.layer1.gate_composer import compose_conditions_cmd
+from clm.layer1.runtime_adapter import evaluate_compose, evaluate_polyglot, run_internal_reference_test
+from clm.layer2.classifier import classify_clm, detect_dialect
+from clm.layer2.file_registrar import register_file_mcard_py
+from clm.layer2.storage import (
+    resolve_handle_content,
+)
+
+_logger = get_logger("clm.layer4.cli")
+
+# ---------------------------------------------------------------------------
+# Runtime dispatch helpers — extracted from evaluate_cmd for modularity
+# ---------------------------------------------------------------------------
+
+def _validate_signatures(clm_root, clm_file):
+    """Validates strict cryptographic signatures via dependency graph. Returns 0 on success, 1 on failure."""
+    bash_cmd = f"""
+    export CLM_ROOT="{clm_root}"
+    export PATH="$CLM_ROOT/kernel/scripts:$PATH"
+    clm_root() {{ echo "$CLM_ROOT"; }}
+    export -f clm_root
+    while IFS= read -r f; do
+        if [[ "$f" != *"clmEval.sh"* && "$f" != *"main.sh"* && "$f" != *"evaluator.sh"* ]]; then
+            source "$f" 2>/dev/null || true
+        fi
+    done < <(find "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap" -name "node_modules" -prune -o -mindepth 2 -name "*.sh" -print)
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap/layer1_cpn_vm/clm_dependency_graph.sh"
+    build_dependency_graph "$1"
+    """
+    proc = subprocess.Popen([get_bash_command(), "-c", bash_cmd, "--", clm_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8")
+    stdout_data, stderr_data = proc.communicate()
+    if proc.returncode != 0:
+        _logger.error("CRITICAL: Sovereign cryptographic verification failed: build_dependency_graph execution failed.")
+        _logger.info(f"Subprocess stderr: {stderr_data}")
+        _logger.info("Strict signatures mode active. Aborting.")
+        return 1
+
+    lines = stdout_data.strip().splitlines()
+    untrusted_nodes = []
+    for line in lines:
+        if not line.strip():
+            continue
+        try:
+            node_data = json.loads(line)
+            if node_data.get("trusted") is False:
+                untrusted_nodes.append(node_data)
+        except Exception:
+            pass
+    if untrusted_nodes:
+        trust_reason = untrusted_nodes[0].get("trust_reason") or "Unknown trust failure"
+        _logger.error(f"CRITICAL: Sovereign cryptographic verification failed: {trust_reason}")
+        _logger.info("Strict signatures mode active. Aborting.")
+        return 1
+    return 0
+
+
+def _run_python_block(clm_root, clm_file, block, concrete, extra_args):
+    """Executes a Python process block. Returns exit code."""
+    _logger.debug(f"[DEBUG_PYTHON_RUN] Executing python block: {block}")
+    script = block.get("script", concrete.get("script", concrete.get("code", "")))
+    script_handle = block.get("script_handle", concrete.get("script_handle", ""))
+    body = ""
+    if script_handle:
+        body = resolve_handle_content(clm_root, script_handle)
+    if not body and script:
+        body = script
+
+    if not body:
+        _logger.error(f"[RUNNER] ❌ Empty Python script block for {clm_file}")
+        return 1
+
+    nested_val = os.environ.pop("CLM_NESTED_EXEC", None)
+    nested_file_val = os.environ.pop("CLM_NESTED_FILE", None)
+    try:
+        env = globals().copy()
+        env.update({
+            "clm_root": clm_root,
+            "clm_file": clm_file,
+            "extra_args": extra_args,
+            "sys": sys,
+            "os": os,
+            "__name__": "__main__"
+        })
+        exec(body, env)
+        return 0
+    except SystemExit as e:
+        return e.code if isinstance(e.code, int) else 0
+    except Exception as e:
+        _logger.error(f"[RUNNER] ❌ Python execution error: {e}")
+        _logger.error("Exception in CLI", exc_info=True)
+        return 1
+    finally:
+        if nested_val is not None:
+            os.environ["CLM_NESTED_EXEC"] = nested_val
+        if nested_file_val is not None:
+            os.environ["CLM_NESTED_FILE"] = nested_file_val
+
+
+def _run_node_library(library, block, concrete, env, extra_args):
+    """Executes a declarative Node.js library call. Returns exit code.
+
+    Story 139.1.5: All Node.js library execution routes through Rust core dispatch-runtime.
+    """
+    lib_name = library.get("name")
+    lib_entry = library.get("entry", "")
+    lib_signature = library.get("signature", "")
+
+    arguments = block.get("arguments", concrete.get("arguments", []))
+    args_json = json.dumps(arguments)
+
+    rust_bin = _resolve_rust_binary(os.environ.get("CLM_ROOT", ""))
+    if not rust_bin:
+        _logger.error("[PAL:node] ❌ clm_rust_core binary not found for library dispatch")
+        return 1
+    script = f"library:{lib_name}:{lib_entry}:{lib_signature}:{args_json}"
+    cmd = [rust_bin, "dispatch-runtime", "--runtime", "node", "--script", script]
+    proc = subprocess.Popen(cmd, env=env)
+    proc.wait()
+    return proc.returncode
+
+
+def _resolve_rust_binary(clm_root):
+    """Find the clm_rust_core binary if it exists. Returns path or None.
+
+    Also searches the real CLM root derived from this script's location, so
+    mock-root tests can dispatch to the built binary even when CLM_ROOT
+    points to a temporary fixture.
+    """
+    import platform as _platform
+
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    # cli.py is at kernel/scripts/clm/layer3/cli.py → CLM root is 4 levels up
+    script_clm_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(script_dir))))
+
+    roots = [clm_root]
+    if os.path.normpath(script_clm_root) != os.path.normpath(clm_root):
+        roots.append(script_clm_root)
+
+    candidates = []
+    for root in roots:
+        candidates.extend([
+            os.path.join(root, "kernel/clm_rust_core/target/release/clm_rust_core"),
+            os.path.join(root, "kernel/clm_rust_core/target/debug/clm_rust_core"),
+        ])
+        if _platform.system() == "Darwin":
+            machine = _platform.machine()
+            if machine == "arm64":
+                candidates.insert(0, os.path.join(root, "kernel/clm_rust_core/target/aarch64-apple-darwin/release/clm_rust_core"))
+                candidates.insert(1, os.path.join(root, "kernel/clm_rust_core/target/aarch64-apple-darwin/debug/clm_rust_core"))
+            elif machine == "x86_64":
+                candidates.insert(0, os.path.join(root, "kernel/clm_rust_core/target/x86_64-apple-darwin/release/clm_rust_core"))
+                candidates.insert(1, os.path.join(root, "kernel/clm_rust_core/target/x86_64-apple-darwin/debug/clm_rust_core"))
+
+    if sys.platform == "win32":
+        candidates = [p + ".exe" for p in candidates]
+    valid = [p for p in candidates if os.path.isfile(p) and os.access(p, os.X_OK)]
+    if valid:
+        return max(valid, key=lambda p: os.path.getmtime(p))
+    return None
+
+
+def _run_node_script(body, clm_root, env, extra_args):
+    """Executes an inline Node.js script via Rust core RuntimeDispatcher. Returns exit code.
+
+    Story 139.1.5: All Node.js execution routes through
+    `clm_rust_core dispatch-runtime --runtime node --script <body>`.
+    Falls back to `node -e <body>` when Rust binary is not compiled.
+    """
+    rust_bin = _resolve_rust_binary(clm_root)
+    if rust_bin:
+        cmd = [rust_bin, "dispatch-runtime", "--runtime", "node", "--script", body]
+    else:
+        cmd = ["node", "-e", body]
+    proc = subprocess.Popen(cmd, env=env)
+    proc.wait()
+    return proc.returncode
+
+
+def _run_node_jscubed(clm_root, clm_file, concrete, env, payload):
+    """Executes via jsCubed dispatcher. Returns exit code.
+
+    Story 139.1.5: All jsCubed execution routes through Rust core dispatch-runtime.
+    Falls back to clm_eval_dispatcher.cjs when Rust binary is not compiled.
+    """
+    rust_bin = _resolve_rust_binary(clm_root)
+    if rust_bin:
+        entry_point = concrete.get("entry_point", concrete.get("operation", ""))
+        script = f"jsCubed:{clm_file}:{entry_point}:{payload}"
+        cmd = [rust_bin, "dispatch-runtime", "--runtime", "node", "--script", script]
+    else:
+        dispatcher = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer1_cpn_vm/clm_eval_dispatcher.cjs")
+        cmd = ["node", dispatcher, clm_file, payload]
+    proc = subprocess.Popen(cmd, env=env)
+    proc.wait()
+    return proc.returncode
+
+
+def _run_node_block(clm_root, clm_file, block, concrete, extra_args):
+    """Executes a JavaScript/Node.js process block. Returns exit code."""
+    _logger.debug(f"[DEBUG_NODE_RUN] Executing node/javascript block: {block}")
+    library = block.get("library")
+    if not library and concrete:
+        library = concrete.get("library")
+    has_library = library is not None and isinstance(library, dict) and "name" in library
+
+    script = block.get("script", concrete.get("script", concrete.get("code", "")))
+    script_handle = block.get("script_handle", concrete.get("script_handle", ""))
+    body = ""
+    if script_handle:
+        body = resolve_handle_content(clm_root, script_handle)
+    if not body and script:
+        body = script
+    has_script = bool(body)
+
+    if has_library and has_script:
+        _logger.error("[PAL:node] ❌ Integrity Breach: manifest cannot define both inline/handle script AND a declarative library!")
+        return 1
+
+    env = os.environ.copy()
+    payload = " ".join(extra_args)
+    if payload:
+        env["CLM_PAYLOAD"] = payload
+        env["TARGET_FILE"] = payload
+    env["CLM_ROOT"] = clm_root
+
+    if has_library:
+        return _run_node_library(library, block, concrete, env, extra_args)
+    elif has_script:
+        return _run_node_script(body, clm_root, env, extra_args)
+    else:
+        return _run_node_jscubed(clm_root, clm_file, concrete, env, payload)
+
+
+def _run_internal_reference(clm_root, clm_file, block, extra_args):
+    """Executes an internal reference test. Returns exit code."""
+
+    # In-process PyO3 evaluation fast-path (INV-418)
+    from clm.cross_cutting.native import evaluate_in_process
+    payload = extra_args[0] if extra_args else None
+    in_proc_res = evaluate_in_process(clm_root, clm_file, payload)
+    if in_proc_res is not None:
+        rc, out = in_proc_res
+        if out:
+            print(out, end="")
+        return rc
+
+    rust_core_release = os.path.join(clm_root, "kernel/clm_rust_core/target/release/clm_rust_core")
+    rust_core_debug = os.path.join(clm_root, "kernel/clm_rust_core/target/debug/clm_rust_core")
+    if sys.platform == "win32":
+        rust_core_release += ".exe"
+        rust_core_debug += ".exe"
+
+    has_rust_binary = os.path.exists(rust_core_release) or os.path.exists(rust_core_debug)
+
+    if os.environ.get("CLM_RUNTIME", "").lower() == "python" or not has_rust_binary:
+        module_name = block.get("module", "")
+        return run_internal_reference_test(clm_root, clm_file, module_name)
+    else:
+        rs_binary = os.path.join(clm_root, "kernel/scripts/clmEval-rs")
+        if not os.path.exists(rs_binary):
+            # Check release first, then debug (or pick newest if both exist)
+            release_bin = os.path.join(clm_root, "kernel/clm_rust_core/target/release/clm_rust_core")
+            debug_bin = os.path.join(clm_root, "kernel/clm_rust_core/target/debug/clm_rust_core")
+            if sys.platform == "win32":
+                release_bin += ".exe"
+                debug_bin += ".exe"
+
+            if os.path.exists(release_bin) and os.path.exists(debug_bin):
+                if os.path.getmtime(release_bin) >= os.path.getmtime(debug_bin):
+                    rs_binary = release_bin
+                else:
+                    rs_binary = debug_bin
+            elif os.path.exists(release_bin):
+                rs_binary = release_bin
+            elif os.path.exists(debug_bin):
+                rs_binary = debug_bin
+
+        if os.path.exists(rs_binary):
+            cmd = [rs_binary, "evaluate", clm_file] + extra_args
+            env = os.environ.copy()
+            env["CLM_NESTED_EXEC"] = "1"
+            env["CLM_NESTED_FILE"] = os.path.abspath(clm_file)
+            proc = subprocess.Popen(cmd, env=env)
+            proc.wait()
+            return proc.returncode
+        else:
+            _logger.error("[RUNNER] ❌ clmEval-rs binary not found!")
+            return 1
+
+
+def _run_shell_block(clm_root, clm_file, block, concrete, extra_args):
+    """Executes a shell process block. Returns exit code.
+
+    Story 139.1.5: Routes through Rust core dispatch-runtime when binary is available.
+    Falls back to bash when Rust binary is not compiled.
+    """
+    script = block.get("script", concrete.get("script", concrete.get("code", "")))
+    script_handle = block.get("script_handle", concrete.get("script_handle", ""))
+    body = ""
+    if script_handle:
+        body = resolve_handle_content(clm_root, script_handle)
+    if not body and script:
+        body = script
+
+    if not body:
+        _logger.error(f"[RUNNER] ❌ Empty shell script block for {clm_file}")
+        return 1
+
+    operation = concrete.get("operation")
+    if operation and f"{operation}()" in body and not body.strip().endswith(f"{operation}") and not body.strip().endswith(f'{operation} "$@"'):
+        body += f'\n\n{operation} "$@"\n'
+
+    if extra_args:
+        import shlex
+        args_str = " ".join(shlex.quote(str(a)) for a in extra_args)
+        body = f"set -- {args_str}\n\n" + body
+
+    rust_bin = _resolve_rust_binary(clm_root)
+    env = os.environ.copy()
+    env["CLM_ROOT"] = clm_root
+    if rust_bin:
+        cmd = [rust_bin, "dispatch-runtime", "--runtime", "shell", "--script", body]
+        proc = subprocess.Popen(cmd, env=env)
+        proc.wait()
+        return proc.returncode
+    else:
+        bootstrap_sh = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/evaluator/shell_utils.sh").replace("\\", "/")
+        core_boot = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer0_core/clm_bootstrap.sh").replace("\\", "/")
+        mcard_store = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer0_core/mcard_storage.sh").replace("\\", "/")
+        mcard_verify = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer0_core/mcard_verification.sh").replace("\\", "/")
+        type_reg = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer0_core/type_registry.sh").replace("\\", "/")
+        grammar_ops = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/governance/grammar_ops.sh").replace("\\", "/")
+        define_grammar = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/governance/define_grammar.sh").replace("\\", "/")
+        yaml_assert = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/governance/yaml_assert_contains.sh").replace("\\", "/")
+        proc_disp = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer1_cpn_vm/process_dispatch.sh").replace("\\", "/")
+        rt_adapters = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer1_cpn_vm/runtime_adapters.sh").replace("\\", "/")
+        init_script = (
+            f"source '{bootstrap_sh}' 2>/dev/null || true;\n"
+            f"source '{core_boot}' 2>/dev/null || true;\n"
+            f"source '{mcard_store}' 2>/dev/null || true;\n"
+            f"source '{mcard_verify}' 2>/dev/null || true;\n"
+            f"source '{type_reg}' 2>/dev/null || true;\n"
+            f"source '{grammar_ops}' 2>/dev/null || true;\n"
+            f"source '{define_grammar}' 2>/dev/null || true;\n"
+            f"source '{yaml_assert}' 2>/dev/null || true;\n"
+            f"source '{proc_disp}' 2>/dev/null || true;\n"
+            f"source '{rt_adapters}' 2>/dev/null || true;\n"
+            + body
+        )
+        proc = subprocess.Popen([get_bash_command(), "-s"], stdin=subprocess.PIPE, env=env)
+        proc.communicate(input=init_script.encode("utf-8"))
+        return proc.returncode
+
+
+# ---------------------------------------------------------------------------
+# Orchestrator — evaluate_cmd now delegates to helpers above
+# ---------------------------------------------------------------------------
+
+def evaluate_cmd(clm_root, clm_file, extra_args):
+    clm_file = resolve_clm_path(clm_root, clm_file)
+    if not os.path.exists(clm_file):
+        sys.exit(f"FATAL: CLM manifest missing at {clm_file}")
+
+    def print_clm_trace(transition_name):
+        if os.environ.get("CLM_NESTED_EXEC", "0") == "1":
+            return
+        if "CLM_DISPATCH_SOCK" not in os.environ:
+            return
+        trace_data = {
+            "type": "trace",
+            "transition": transition_name,
+            "agent": "did:pkc:ca:darwin:root-agent",
+            "agent_class": "root-agent",
+            "sponsor": "self",
+            "pcard": os.environ.get("CLM_LAST_MCARD_HASH", ""),
+            "cert": "",
+            "merkle": "",
+            "places": {},
+            "pinv_held": True
+        }
+        sys.stdout.write(f"CLM_TRACE_JSON:{json.dumps(trace_data)}\n")
+        sys.stdout.flush()
+
+    print_clm_trace("verify_precondition")
+
+    if os.environ.get("CLM_STRICT_SIGNATURES", "0") == "1":
+        rc = _validate_signatures(clm_root, clm_file)
+        if rc != 0:
+            return rc
+
+    # Lazy load algebra to prevent circular imports
+    from clm.layer0.algebra import load_normalized_manifest
+    try:
+        yaml_data = load_normalized_manifest(clm_root, clm_file)
+    except Exception as e:
+        sys.exit(f"FATAL: Failed to parse CLM YAML: {e}")
+
+    classification = classify_clm(yaml_data)
+    inner = yaml_data.get("clm", yaml_data)
+    has_process = False
+    if isinstance(inner, dict):
+        concrete = inner.get("concrete_impl", {})
+        if concrete and ("process" in concrete or "process_behavior_exec" in concrete or "runtime" in concrete):
+            has_process = True
+    elif "process" in inner or "runtime" in inner:
+        has_process = True
+
+    if has_process:
+        classification = "Function"
+
+    # Face B manifests (with pending_cases) are always "Function" — they have
+    # executable behavior even without a concrete_impl block.
+    if isinstance(inner, dict) and ("pending_cases" in inner or inner.get("face") == "B"):
+        classification = "Function"
+
+    if classification == "Number":
+        h = clm_hash_file(clm_file)
+        print(h)
+        return 0
+
+    dialect = detect_dialect(yaml_data, classification)
+
+    register_file_mcard_py(clm_root, clm_file)
+
+    skip_conditions = os.environ.get("CLM_SKIP_CONDITIONS", "0") == "1"
+    nested_exec = False
+    if os.environ.get("CLM_NESTED_EXEC", "0") == "1":
+        nested_file = os.environ.get("CLM_NESTED_FILE")
+        if nested_file and os.path.abspath(clm_file) == os.path.abspath(nested_file):
+            nested_exec = True
+
+    if not skip_conditions and not nested_exec:
+        rc = compose_conditions_cmd(clm_root, clm_file, "pre")
+        if rc != 0:
+            _logger.info("CRITICAL: Pre-Gate Failed.")
+            return rc
+
+    inner = yaml_data.get("clm", yaml_data)
+    concrete = inner.get("concrete_impl", {})
+
+    # --- Face B auto-dispatch: manifests with pending_cases run the
+    #     Balanced Expectations runner automatically, no concrete_impl needed.
+    face = inner.get("face", "")
+    has_pending = "pending_cases" in inner
+    if face == "B" or has_pending:
+        eval_rc = run_balanced_expectations(clm_root, clm_file)
+        if not skip_conditions and not nested_exec:
+            print_clm_trace("validate_postcondition")
+            rc = compose_conditions_cmd(clm_root, clm_file, "post", eval_rc)
+            if rc != 0:
+                return rc
+            print_clm_trace("commit_witness")
+        return eval_rc
+
+    process = concrete.get("process", {})
+
+    process_blocks = []
+    if isinstance(process, dict):
+        process_blocks = [process]
+    elif isinstance(process, list):
+        process_blocks = process
+
+    print_clm_trace("execute_payload")
+    eval_rc = 0
+    for block in process_blocks:
+        p_type = block.get("type", concrete.get("runtime", "shell"))
+        if dialect.startswith("M:"):
+            p_type = dialect.split("M:")[1]
+
+        if p_type == "polyglot":
+            eval_rc = evaluate_polyglot(clm_root, clm_file, yaml_data, extra_args)
+        elif p_type == "compose":
+            eval_rc = evaluate_compose(clm_root, clm_file, block, extra_args)
+        elif p_type == "triad":
+            from clm.layer1.runtime_adapter import evaluate_triad
+            eval_rc = evaluate_triad(clm_root, clm_file, block, extra_args)
+        elif p_type == "triad_pipeline":
+            from clm.layer1.runtime_adapter import evaluate_triad_pipeline
+            eval_rc = evaluate_triad_pipeline(clm_root, clm_file, block, extra_args)
+        elif p_type == "open_interpreter":
+            from .open_interpreter_adapter import evaluate_open_interpreter
+            eval_rc = evaluate_open_interpreter(clm_root, clm_file, block, extra_args)
+        elif p_type == "python":
+            eval_rc = _run_python_block(clm_root, clm_file, block, concrete, extra_args)
+        elif p_type in ("javascript", "node"):
+            eval_rc = _run_node_block(clm_root, clm_file, block, concrete, extra_args)
+        elif p_type == "internal_reference":
+            eval_rc = _run_internal_reference(clm_root, clm_file, block, extra_args)
+        else:
+            eval_rc = _run_shell_block(clm_root, clm_file, block, concrete, extra_args)
+
+        if eval_rc != 0:
+            break
+
+    if not skip_conditions and not nested_exec:
+        print_clm_trace("validate_postcondition")
+        rc = compose_conditions_cmd(clm_root, clm_file, "post", eval_rc)
+        if rc != 0:
+            _logger.info("CRITICAL: Post-Gate Failed.")
+            return rc
+        print_clm_trace("commit_witness")
+
+    return eval_rc
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point — main()
+# ---------------------------------------------------------------------------
+
+def main():
+    import sys
+    if sys.platform == "win32":
+        try:
+            sys.stdout.reconfigure(encoding="utf-8")
+            sys.stderr.reconfigure(encoding="utf-8")
+        except AttributeError:
+            pass
+
+    clm_root = os.environ.get("CLM_ROOT") or os.getcwd()
+    if clm_root:
+        # Normalize Git Bash / MSYS2 Unix-style paths on Windows
+        if sys.platform == "win32":
+            if clm_root.startswith('/') and len(clm_root) >= 3 and clm_root[2] == '/':
+                drive = clm_root[1].upper()
+                clm_root = drive + ":" + clm_root[2:]
+            elif clm_root.startswith('/') and len(clm_root) == 2:
+                drive = clm_root[1].upper()
+                clm_root = drive + ":\\"
+            clm_root = clm_root.replace('/', '\\')
+        os.environ["CLM_ROOT"] = clm_root
+
+    cache_compiler = os.path.join(clm_root, "scripts", "bootstrap", "layer0_core", "compile_cache.py")
+    if os.path.exists(cache_compiler):
+        with contextlib.suppress(Exception):
+            proc = subprocess.Popen([sys.executable, cache_compiler], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            proc.wait()
+
+    args = sys.argv[1:]
+
+    if "-q" in args:
+        args.remove("-q")
+    if "--quiet" in args:
+        args.remove("--quiet")
+
+    if not args:
+        print("Usage: clm_runner.py <command> [args...]")
+        sys.exit(1)
+
+    command = args[0]
+
+    from clm.layer4.commands import KNOWN_COMMANDS, dispatch_command
+
+    if command not in KNOWN_COMMANDS:
+        args = ["evaluate"] + args
+        command = "evaluate"
+
+    try:
+        rc = dispatch_command(command, args[1:])
+        sys.exit(rc)
+    except SystemExit as e:
+        sys.exit(e.code)
+    except Exception as e:
+        _logger.error(f"Error executing command '{command}': {e}")
+        _logger.error("Exception in CLI", exc_info=True)
+        sys.exit(1)
+