clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/runtime_adapter.py

@@ -0,0 +1,718 @@
+"""CLM Runtime Adapter — Polyglot runtime execution and cross-runtime parity verification.
+
+Handles the dispatch of CLM payloads to different runtimes (shell, python, node, rust),
+cross-runtime parity verification, composite evaluation, and internal reference tests.
+"""
+
+import json
+import os
+import subprocess as _sp
+import sys
+from typing import Any
+
+import yaml
+
+from clm.cross_cutting.clm_logger import get_logger
+from clm.cross_cutting.vcard import vcard_sandwich
+from clm.layer0.context import CLMContext
+from clm.layer0.utils import (
+    clm_hash_file,
+    clm_hash_string,
+    detect_host_os,
+    get_bash_command,
+    resolve_clm_path,
+)
+
+from .verifier import (
+    check_precondition_py,
+    emit_exec_mcard_py,
+    get_load_manifest,
+    normalize_output_py,
+    resolve_active_hashes_py,
+)
+
+_logger = get_logger("clm.layer1.runtime_adapter")
+
+
+def _resolve_rust_binary(clm_root: str) -> str | None:
+    """Locate the compiled clm_rust_core binary.
+
+    Sprint 144 (GAP-15): Try manifest-based resolution first via
+    `clm_rust_core resolve-binary --handle runtime:clm_rust_core`.
+    Fall back to hardcoded path list for first-boot / no-database scenarios.
+    """
+    base = os.path.join(clm_root, "kernel", "clm_rust_core", "target")
+    candidates = []
+    for profile in ("release", "debug"):
+        candidate = os.path.join(base, profile, "clm_rust_core")
+        candidates.append(candidate)
+
+    # Find any available Rust binary to call resolve-binary
+    rust_bin_for_resolve = None
+    for path in candidates:
+        if os.path.exists(path):
+            rust_bin_for_resolve = path
+            break
+
+    # Try manifest-based resolution first (GAP-15)
+    if rust_bin_for_resolve:
+        try:
+            proc = _sp.Popen(
+                [rust_bin_for_resolve, "resolve-binary", "--handle", "runtime:clm_rust_core"],
+                stdout=_sp.PIPE, stderr=_sp.PIPE, text=True
+            )
+            stdout, _ = proc.communicate(timeout=5)
+            if proc.returncode == 0 and stdout.strip():
+                resolved = stdout.strip()
+                if os.path.exists(resolved):
+                    return resolved
+        except Exception:
+            pass
+
+    # Fallback: hardcoded path list
+    for path in candidates:
+        if os.path.exists(path):
+            return path
+    return None
+
+
+def _call_rust_binary(
+    exe: str,
+    args: list[str],
+    env: dict[str, str] | None = None,
+    stdin_data: str | None = None,
+) -> tuple[int, str, str]:
+    """Invoke the Rust binary with optional stdin and return (exit_code, stdout, stderr)."""
+    cmd = [exe] + args
+    proc = _sp.Popen(
+        cmd,
+        stdout=_sp.PIPE,
+        stderr=_sp.PIPE,
+        stdin=_sp.PIPE if stdin_data is not None else None,
+        text=True,
+        encoding="utf-8",
+        env=env or os.environ.copy(),
+    )
+    stdout_data, stderr_data = proc.communicate(input=stdin_data)
+    return proc.returncode, stdout_data, stderr_data
+
+
+def run_internal_reference_test(clm_root: str, clm_file: str, module_name: str) -> int:
+    """
+    Runs an internal reference test for a specific module, simulating execution context.
+
+    Args:
+        clm_root (str): The root directory of the CLM workspace.
+        clm_file (str): The path to the CLM PCard.
+        module_name (str): The name of the internal module/test to run.
+
+    Returns:
+        int: The exit code of the test.
+    """
+    if module_name == "clm_rust_core::integration::test_mdns_peer_discovery":
+        _logger.warning("⚠️  STUB: mDNS peer discovery test not implemented in Python runtime; requires Rust binary (clm_rust_core)")
+        return 1
+
+    test_name = module_name.split("::")[-1]
+    overrides = {
+        "test_petri_net_suite": "petri_net_cases.sh",
+        "test_petri_binding_suite": "petri_binding_cases.sh",
+        "test_petri_invariants": "petri_invariant_cases.sh",
+        "test_monadic_pcard_resolve_handle": "test_monadic_pcards.sh",
+        "test_monadic_pcard_check_precondition": "test_monadic_pcards.sh",
+        "test_monadic_pcard_execute_payload": "test_monadic_pcards.sh",
+        "test_monadic_pcard_validate_postcondition": "test_monadic_pcards.sh",
+        "test_vcard_pre": "test_monadic_pcards.sh",
+    }
+    target_filename = overrides.get(test_name, f"{test_name}.sh")
+    script_rel = None
+    for layer in ("00_microkernel", "01_cpn_vm", "02_storage", "03_network"):
+        candidate = f"tests/{layer}/{target_filename}"
+        if os.path.exists(os.path.join(clm_root, candidate)):
+            script_rel = candidate
+            break
+
+    if not script_rel:
+        for root, _dirs, files in os.walk(os.path.join(clm_root, "tests")):
+            if target_filename in files:
+                script_rel = os.path.relpath(os.path.join(root, target_filename), clm_root)
+                break
+
+    if not script_rel:
+        _logger.info(f"ERROR: Unknown internal reference module '{module_name}' (script not found)")
+        return 1
+
+    test_func = test_name
+    if test_name == "test_petri_math":
+        test_func = "test_petri_math_suite"
+    elif test_name == "test_petri_invariants":
+        test_func = "test_petri_invariant_suite"
+    elif test_name == "test_vcard_pre":
+        test_func = "test_monadic_pcard_check_precondition"
+    script_path = os.path.join(clm_root, script_rel)
+
+    host_os = detect_host_os()
+    import platform as _plat
+    arch = "amd64" if _plat.machine() in ("x86_64", "AMD64") else "arm64"
+    script_content = f"""
+export CLM_ROOT="{clm_root}"
+export CLM_RUNNER="rust"
+export PATH="$CLM_ROOT/.venv/Scripts:$CLM_ROOT/.venv/bin:$CLM_ROOT/kernel/bin/{host_os}-{arch}:$CLM_ROOT/kernel/scripts:$PATH"
+clm_root() {{ echo "$CLM_ROOT"; }}
+export -f clm_root
+
+# Intercept exit to prevent bootstrap scripts from terminating the shell
+exit() {{ return "${{1:-0}}"; }}
+
+while IFS= read -r f; do
+    if [[ "$f" != *"clmEval.sh"* && "$f" != *"main.sh"* && "$f" != *"evaluator.sh"* && "$f" != *"install_vs_buildtools.sh"* && "$f" != *"patch_mcard_venv.sh"* ]]; then
+        source "$f" 2>/dev/null || true
+    fi
+done < <(find "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap" -name "node_modules" -prune -o -name "*.sh" -print)
+
+unset -f exit
+
+source "{script_path}" && {test_func}
+"""
+    rust_exe = _resolve_rust_binary(clm_root)
+    if rust_exe:
+        import json as _json
+        script_input = {
+            "runtime": "shell",
+            "script": script_content,
+            "env": dict(os.environ),
+            "entry_point": "",
+            "cargo_test": "",
+            "args": [],
+            "clm_root": clm_root,
+        }
+        result = _call_rust_binary(rust_exe, ["exec-runtime-script"], env=None, stdin_data=_json.dumps(script_input))
+        if result[0] == 0:
+            try:
+                output = _json.loads(result[1])
+                return output.get("exit_code", 1)
+            except Exception:
+                pass
+        return result[0]
+    proc = _sp.Popen([get_bash_command(), "-c", script_content])
+    proc.wait()
+    return proc.returncode
+
+def _extract_ctx(clm_root: str, runtime: str, script_content: str, inputs: dict[str, Any], entry_point: str, cargo_test: str, a_hash: str, c_hash: str) -> CLMContext:
+    return CLMContext.create_default(clm_root)
+
+def _extract_meta(clm_root: str, runtime: str, script_content: str, inputs: dict[str, Any], entry_point: str, cargo_test: str, a_hash: str, c_hash: str) -> dict[str, Any]:
+    from clm.layer0.utils import clm_hash_string
+    return {
+        "operation": f"polyglot_execution_{runtime}",
+        "runtime": runtime,
+        "script_hash": clm_hash_string(script_content),
+        "input_place_hashes": [],
+        "agent_did": os.environ.get("ACTIVE_AGENT_DID", "did:clm:bootstrap"),
+        "sponsor_did": ""
+    }
+
+@vcard_sandwich(extract_ctx_func=_extract_ctx, extract_meta_func=_extract_meta)
+def _polyglot_runtime_execute(clm_root: str, runtime: str, script_content: str, inputs: dict[str, Any], entry_point: str, cargo_test: str, a_hash: str, c_hash: str) -> tuple[int, str, str]:
+    run_status = 0
+    stdout_data = ""
+    stderr_data = ""
+
+    env = os.environ.copy()
+    for k, v in inputs.items():
+        env[k] = str(v)
+
+    args = [str(v) for v in inputs.values()]
+
+    rust_exe = _resolve_rust_binary(clm_root)
+    if rust_exe and runtime in ("shell", "python", "node", "rust"):
+        import json as _json
+        script_input = {
+            "runtime": runtime,
+            "script": script_content,
+            "env": {k: str(v) for k, v in env.items()},
+            "entry_point": entry_point or "",
+            "cargo_test": cargo_test or "",
+            "args": args,
+            "clm_root": clm_root,
+        }
+        result = _call_rust_binary(rust_exe, ["exec-runtime-script"], env=None, stdin_data=_json.dumps(script_input))
+        if result[0] == 0:
+            try:
+                output = _json.loads(result[1])
+                return output.get("exit_code", 1), output.get("stdout", ""), output.get("stderr", "")
+            except Exception:
+                pass
+        return result[0], result[1], result[2]
+
+    if runtime == "shell":
+        body = script_content
+        if entry_point:
+            body += f"\n\nif type {entry_point} &>/dev/null; then\n  {entry_point} " + " ".join([f'"{a}"' for a in args]) + "\nfi\n"
+
+        proc = _sp.Popen([get_bash_command(), "-c", body], stdout=_sp.PIPE, stderr=_sp.PIPE, text=True, encoding="utf-8", env=env)
+        stdout_data, stderr_data = proc.communicate()
+        run_status = proc.returncode
+    elif runtime == "python":
+        proc = _sp.Popen([sys.executable, "-c", script_content] + args, stdout=_sp.PIPE, stderr=_sp.PIPE, text=True, encoding="utf-8", env=env)
+        stdout_data, stderr_data = proc.communicate()
+        run_status = proc.returncode
+    elif runtime == "node":
+        proc = _sp.Popen(["node", "-e", script_content] + args, stdout=_sp.PIPE, stderr=_sp.PIPE, text=True, encoding="utf-8", env=env)
+        stdout_data, stderr_data = proc.communicate()
+        run_status = proc.returncode
+    elif runtime == "rust":
+        if cargo_test:
+            pwd_orig = os.getcwd()
+            try:
+                os.chdir(os.path.join(clm_root, "kernel/clm_rust_core"))
+                proc = _sp.Popen(["./target/release/clm_rust_core", "run-test", cargo_test], stdout=_sp.PIPE, stderr=_sp.PIPE, text=True, encoding="utf-8", env=env)
+                stdout_data, stderr_data = proc.communicate()
+                run_status = proc.returncode
+            except Exception:
+                cmd = ["./target/debug/clm_rust_core", "run-test", cargo_test]
+                if not os.path.exists(cmd[0]):
+                    cmd = ["cargo", "test", "--manifest-path", "Cargo.toml", "--", cargo_test]
+                proc = _sp.Popen(cmd, stdout=_sp.PIPE, stderr=_sp.PIPE, text=True, encoding="utf-8", env=env)
+                stdout_data, stderr_data = proc.communicate()
+                run_status = proc.returncode
+            finally:
+                os.chdir(pwd_orig)
+        else:
+            import tempfile
+            temp_dir = tempfile.mkdtemp()
+            src_file = os.path.join(temp_dir, "main.rs")
+            bin_file = os.path.join(temp_dir, "app.exe" if sys.platform == "win32" else "app")
+            if "fn main" not in script_content:
+                wrapped_content = "use std::io::{self, Read};\nfn main() {\n" + script_content + "\n}\n"
+            else:
+                wrapped_content = script_content
+            with open(src_file, "w", encoding="utf-8") as fh:
+                fh.write(wrapped_content)
+            try:
+                compile_proc = _sp.Popen(["rustc", "-O", "-o", bin_file, src_file], stdout=_sp.PIPE, stderr=_sp.PIPE, text=True, encoding="utf-8")
+                compile_out, compile_err = compile_proc.communicate()
+                if compile_proc.returncode != 0:
+                    if "linking with `link.exe` failed" in compile_err or "link: extra operand" in compile_err:
+                        _logger.warning(f"[PAL:polyglot] ⚠️ Rust compilation skipped (linker unavailable): {compile_err.strip()}")
+                        return 0, "", "skipped: rustc linker unavailable"
+                    _logger.error(f"[PAL:polyglot] ❌ Rust compilation failed:\n{compile_err}")
+                    return 1, "", compile_err
+                proc = _sp.Popen([bin_file] + args, stdout=_sp.PIPE, stderr=_sp.PIPE, text=True, encoding="utf-8", env=env)
+                stdout_data, stderr_data = proc.communicate()
+                run_status = proc.returncode
+            finally:
+                import shutil
+                shutil.rmtree(temp_dir, ignore_errors=True)
+
+    return run_status, stdout_data, stderr_data
+def evaluate_polyglot(clm_root: str, clm_file: str, yaml_data: dict[str, Any], extra_args: list[str] | None) -> int:
+    """
+    Evaluates a polyglot CLM process, executing it in the specified target runtimes (e.g. Python, Rust, Node).
+
+    Args:
+        clm_root (str): The root directory of the CLM workspace.
+        clm_file (str): The path to the CLM PCard.
+        yaml_data (Dict[str, Any]): The parsed manifest data.
+        extra_args (Optional[List[str]]): Additional command-line arguments.
+
+    Returns:
+        int: The overall exit code from execution.
+    """
+    inner = yaml_data.get("clm", yaml_data)
+    concrete = inner.get("concrete_impl", {})
+    process = concrete.get("process", {})
+    entry_point = process.get("entry_point") or concrete.get("operation")
+
+    balanced_exp = inner.get("balanced_exp", {})
+    polyglot_cases = balanced_exp.get("polyglot_cases", [])
+
+    case_name = None
+    if extra_args:
+        for arg in extra_args:
+            for case in polyglot_cases:
+                if case.get("name") == arg:
+                    case_name = arg
+                    break
+            if case_name:
+                break
+
+    if not case_name and polyglot_cases:
+        case_name = polyglot_cases[0].get("name")
+
+    case_dict = None
+    for case in polyglot_cases:
+        if case.get("name") == case_name:
+            case_dict = case
+            break
+
+    if not case_dict:
+        _logger.error(f"[PAL:polyglot] ❌ No case found for name '{case_name}' in: {clm_file}")
+        return 1
+
+    given = case_dict.get("given", {})
+    runtimes = given.get("runtimes", [])
+    if not runtimes:
+        _logger.error("[PAL:polyglot] ❌ No runtimes specified in Gherkin cover")
+        return 1
+
+    inputs = {k: v for k, v in given.items() if k not in ("runtimes", "requires")}
+    a_hash, c_hash = resolve_active_hashes_py(clm_file)
+
+    env_runtime = os.environ.get("CLM_POLYGLOT_RUNTIME")
+    active_runtimes = [env_runtime] if env_runtime else runtimes
+
+    executed_runtimes = []
+    runtime_outputs = []
+    runtime_exit_codes = []
+    runtime_exec_hashes = []
+
+    for runtime in active_runtimes:
+        if runtime not in runtimes:
+            _logger.info(f"[PAL:polyglot] ⏭️ Target runtime '{runtime}' not requested in Gherkin cover: {runtimes}")
+            continue
+
+        if runtime not in ("shell", "python", "rust", "node", "channel", "wasm", "javascript-browser", "llm"):
+            if env_runtime:
+                _logger.error(f"[PAL:polyglot] ❌ Target runtime '{runtime}' is not supported")
+                return 1
+            else:
+                _logger.info(f"[PAL:polyglot] ⏭️ Skipping unsupported runtime '{runtime}' in cover")
+                continue
+
+        requires = given.get("requires", {})
+        req_guard = requires.get(runtime)
+        if req_guard and not check_precondition_py(req_guard):
+            _logger.info(f"[PAL:polyglot] ⏭️ Pruning runtime '{runtime}' (precondition not met: {req_guard})")
+            continue
+
+        impls = process.get("implementations", {})
+        rt_impl = impls.get(runtime, {})
+        script_content = rt_impl.get("script", "")
+        script_handle = rt_impl.get("script_handle", "")
+        cargo_test = rt_impl.get("cargo_test", "")
+
+        if not script_content:
+            if script_handle and script_handle.startswith("script:"):
+                target = "clm.layer2.storage"
+                mod = sys.modules.get(target)
+                if mod is None:
+                    __import__(target)
+                    mod = sys.modules.get(target)
+                script_content = mod.resolve_handle_content(clm_root, script_handle) if mod else ""
+            elif cargo_test and runtime == "rust":
+                script_content = "CARGO_TEST_EXECUTION"
+
+        if not script_content:
+            if script_handle:
+                print(yaml.dump({
+                    "type": "meta/content_missing",
+                    "handle": script_handle,
+                    "medium_hint": "db",
+                    "uri": f"db://content_memory/{script_handle}"
+                }))
+                return 2
+            else:
+                _logger.error(f"[PAL:polyglot] ❌ No script or cargo_test implementation found for runtime '{runtime}' in: {clm_file}")
+                return 1
+
+        run_status, stdout_data, stderr_data = _polyglot_runtime_execute(clm_root, runtime, script_content, inputs, entry_point, cargo_test, a_hash or "", c_hash or "")
+
+        if stderr_data:
+            sys.stderr.write(stderr_data)
+
+        inputs_json_str = json.dumps(inputs, indent=2)
+        exec_hash_input = f"inputs: {inputs_json_str} | outputs: {stdout_data} | exit_code: {run_status} | runtime_facts: {os.environ.get('CLM_RUNTIME_FACTS', '')}"
+        exec_hash = clm_hash_string(exec_hash_input)
+
+        executed_runtimes.append(runtime)
+        runtime_outputs.append(stdout_data)
+        runtime_exit_codes.append(run_status)
+        runtime_exec_hashes.append(exec_hash)
+
+    if not executed_runtimes:
+
+        _logger.error("[PAL:polyglot] ❌ No runtimes were successfully executed.")
+        return 1
+
+    first_out = runtime_outputs[0]
+    first_code = runtime_exit_codes[0]
+    first_norm = normalize_output_py(first_out)
+
+    parity_failed = False
+    mismatch_rt = ""
+    mismatch_out = ""
+
+    for i in range(1, len(executed_runtimes)):
+        r_name = executed_runtimes[i]
+        r_out = runtime_outputs[i]
+        r_code = runtime_exit_codes[i]
+        r_norm = normalize_output_py(r_out)
+
+        if r_code != first_code:
+            parity_failed = True
+            mismatch_rt = r_name
+            mismatch_out = f"Exit code mismatch: {executed_runtimes[0]}={first_code} vs {r_name}={r_code}"
+            break
+        if r_norm != first_norm:
+            parity_failed = True
+            mismatch_rt = r_name
+            mismatch_out = r_out
+            break
+
+    if parity_failed:
+        _logger.info("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓")
+        _logger.info("┃  COHOMOLOGICAL OBSTRUCTION: Cross-Runtime Parity Fail ┃")
+        _logger.info("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛")
+        _logger.info(f"  Divergence detected between '{executed_runtimes[0]}' and '{mismatch_rt}'!")
+        _logger.info("  -------------------------------------------------")
+        _logger.info(f"  Output of '{executed_runtimes[0]}':")
+        _logger.info(first_out)
+        _logger.info(f"  Output of '{mismatch_rt}':")
+        _logger.info(mismatch_out)
+        _logger.info("  -------------------------------------------------")
+
+        import difflib
+        diff_lines = list(difflib.unified_diff(
+            first_norm.splitlines(keepends=True),
+            normalize_output_py(mismatch_out).splitlines(keepends=True),
+            fromfile=f"norm_{executed_runtimes[0]}",
+            tofile=f"norm_{mismatch_rt}"
+        ))
+        sys.stderr.writelines(diff_lines)
+        return 1
+
+    if len(executed_runtimes) > 1:
+        sorted_hashes = sorted(runtime_exec_hashes)
+        fold_input = "".join(sorted_hashes)
+        parity_hash = clm_hash_string(fold_input)
+
+        runtimes_str = ", ".join([f'"{r}"' for r in executed_runtimes])
+        extra_parity = f'parity_hash: "{parity_hash}"\nruntimes: [{runtimes_str}]'
+        parity_file = emit_exec_mcard_py(clm_root, "polyglot_parity", parity_hash, extra_parity, a_hash or "", c_hash or "")
+        if parity_file:
+            _logger.info(f"[PAL:polyglot] ✅ Parity verified. parity_hash = {parity_hash} ({parity_file})")
+
+    print(first_out, end="")
+    return first_code
+
+def evaluate_compose(clm_root: str, clm_file: str, block: dict[str, Any], extra_args: list[str] | None) -> int:
+    """
+    Evaluates a composite operation, evaluating step by step sequentially or otherwise.
+
+    Args:
+        clm_root (str): The root directory of the CLM workspace.
+        clm_file (str): The path to the parent CLM PCard.
+        block (Dict[str, Any]): The process block declaring steps.
+        extra_args (Optional[List[str]]): Additional execution arguments.
+
+    Returns:
+        int: The exit code (0 if all steps succeed).
+    """
+    load_normalized_manifest_fn = get_load_manifest()
+    _logger.info("[PAL] Dispatching to compose runtime adapter...")
+    compose_mode = block.get("compose_mode", "sequential")
+    steps = block.get("steps", [])
+
+    if not steps:
+        print("[COMPOSE_FN]  No steps declared — identity (no-op)")
+        return 0
+
+    print(f"[COMPOSE_FN] Mode: {compose_mode} | Steps: {len(steps)}")
+
+    # Lazy import evaluate_cmd dynamically to prevent circular dependencies
+    from clm.layer1.eval_callback import evaluate_or_fail
+
+    for i, step_ref in enumerate(steps):
+        step_file = resolve_clm_path(clm_root, step_ref)
+        if not step_file or not os.path.exists(step_file):
+            _logger.error(f"[COMPOSE_FN] Step {i+1}: failed to load '{step_ref}'")
+            return 1
+
+        try:
+            step_data = load_normalized_manifest_fn(clm_root, step_file)
+            inner_step = step_data.get("clm", step_data)
+            step_op = inner_step.get("concrete_impl", {}).get("operation", "unknown")
+        except Exception:
+            step_op = "unknown"
+
+        print(f"[COMPOSE_FN]   Step {i+1}: {step_op} (from {step_ref})")
+
+        rc = evaluate_or_fail(clm_root, step_file, extra_args)
+        if rc != 0:
+            return rc
+
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Sprint 130.1 — Dynamic Triad Runner
+# ---------------------------------------------------------------------------
+
+def evaluate_triad(clm_root: str, clm_file: str, block: dict[str, Any], extra_args: list[str] | None) -> int:
+    """Evaluate a Model Card Triad (Abstract, Concrete, Balanced) sequentially.
+
+    1. Loads the Abstract face (Face A) -> computes content hash
+    2. Loads the Concrete face (Face C) -> computes content hash
+    3. Injects A and C hashes into env vars for CelStore to capture
+    4. Evaluates the Balanced face (Face B) under this enriched context
+    5. Cleans up triad env vars to prevent cross-stage contamination
+
+    Uses CLMLogger with structured fields for cross-runtime traceability.
+    """
+    # Lazy import via callback registry to avoid Layer 1→3 upward dependency
+    from clm.layer1.eval_callback import evaluate_or_fail
+
+    stage = block.get("stage")
+    name = block.get("name")
+    operation = f"stage{stage}_{name}"
+
+    _logger.info("Triad validation starting", op=operation)
+
+    # 1. Resolve paths to A, C, and B faces
+    import yaml
+    layer = "0"
+    try:
+        with open(clm_file, "r") as f:
+            data = yaml.safe_load(f)
+            layer = str(data.get("clm", {}).get("layer", "0"))
+    except Exception:
+        # fallback to parsing path
+        for l in ("0", "1", "2", "3", "4"):
+            if f"layer{l}" in clm_file:
+                layer = l
+                break
+
+    abstract_path = resolve_clm_path(clm_root, f"computable_knowledge/Abstract/layer{layer}/stage{stage}_{name}.yaml")
+    concrete_path = resolve_clm_path(clm_root, f"computable_knowledge/Concrete/layer{layer}/stage{stage}_{name}.yaml")
+    balanced_path = resolve_clm_path(clm_root, f"computable_knowledge/Balanced/layer{layer}/stage{stage}_{name}.yaml")
+
+    if not abstract_path or not os.path.exists(abstract_path):
+        _logger.error(f"Triad Face A not found: stage{stage}_{name}", op=operation)
+        return 1
+    if not concrete_path or not os.path.exists(concrete_path):
+        _logger.error(f"Triad Face C not found: stage{stage}_{name}", op=operation)
+        return 1
+    if not balanced_path or not os.path.exists(balanced_path):
+        _logger.error(f"Triad Face B not found: stage{stage}_{name}", op=operation)
+        return 1
+
+    # 2. Evaluate Abstract and Concrete (computes hashes and registers in DB)
+    rc = evaluate_or_fail(clm_root, abstract_path, extra_args)
+    if rc != 0:
+        _logger.error("Triad Face A (Abstract) failed", op=operation)
+        return rc
+
+    rc = evaluate_or_fail(clm_root, concrete_path, extra_args)
+    if rc != 0:
+        _logger.error("Triad Face C (Concrete) failed", op=operation)
+        return rc
+
+    # 3. Compute hashes for Triadic Coherence
+    a_hash = clm_hash_file(abstract_path)
+    c_hash = clm_hash_file(concrete_path)
+
+    _logger.info("Triad hashes computed", op=operation, pcard_hash=a_hash)
+
+    # 4. Inject hashes into env vars for CelStore to capture during Face B
+    os.environ["CLM_TRIAD_ABSTRACT_HASH"] = a_hash
+    os.environ["CLM_TRIAD_CONCRETE_HASH"] = c_hash
+
+    # 5. Evaluate Balanced Face
+    rc = evaluate_or_fail(clm_root, balanced_path, extra_args)
+    if rc == 0:
+        _logger.info("Triad validation passed", op=operation)
+    else:
+        _logger.error("Triad Face B (Balanced) failed", op=operation)
+
+    # 6. Clean up triad env vars to prevent cross-stage contamination
+    os.environ.pop("CLM_TRIAD_ABSTRACT_HASH", None)
+    os.environ.pop("CLM_TRIAD_CONCRETE_HASH", None)
+
+    return rc
+
+
+# ---------------------------------------------------------------------------
+# Sprint 130.4 — Monadic Pipeline Chaining
+# ---------------------------------------------------------------------------
+
+def evaluate_triad_pipeline(clm_root: str, clm_file: str, block: dict[str, Any], extra_args: list[str] | None) -> int:
+    """Chain multiple triad stages via CelStore.bind() (monadic >>=).
+
+    Each stage's output state token becomes the next stage's precondition
+    input.  After each stage, flush_action_log() persists the action_log
+    to execution_log.db, making the Flux event store durable.
+    """
+    from types import SimpleNamespace
+
+    from clm.cross_cutting.cel_store import CelStore, EnvSlice, StateSlice
+    from clm.layer0.utils import clm_hash_string
+
+    stages = block.get("stages", [])
+    if not stages:
+        _logger.error("No stages defined in triad_pipeline")
+        return 1
+
+    # Detect layer name dynamically
+    layer_name = "layer0"
+    try:
+        import yaml
+        with open(clm_file, "r") as f:
+            data = yaml.safe_load(f)
+            layer_val = data.get("clm", {}).get("layer", "0")
+            layer_name = f"layer{layer_val}"
+    except Exception:
+        for l in ("0", "1", "2", "3", "4"):
+            if f"layer{l}" in clm_file:
+                layer_name = f"layer{l}"
+                break
+
+    # Initialize monadic state with unit() — the "seed" store
+    pipeline_store = CelStore(
+        state=StateSlice(inputs={"pipeline": layer_name}),
+        env=EnvSlice(clm_root=clm_root, os=os),
+    )
+    pipeline_store = pipeline_store.unit({"pipeline": layer_name, "stage": 0})
+
+    overall_rc = 0
+    flush_ctx = SimpleNamespace(root=clm_root)
+
+    for stage_block in stages:
+        stage = stage_block["stage"]
+        name = stage_block["name"]
+        operation = f"stage{stage}_{name}"
+
+        _logger.info(f"Pipeline stage {stage} starting", op=operation)
+
+        def _run_stage(store: CelStore, prev_result: Any, _stage: str = stage, _name: str = name, _op: str = operation) -> tuple[CelStore, int]:
+            rc = evaluate_triad(clm_root, clm_file,
+                                {"stage": _stage, "name": _name}, extra_args)
+            if rc != 0:
+                _logger.error(f"Pipeline stage {_stage} failed", op=_op)
+                return store, rc
+
+            # Capture this stage's output hash as the next stage's precondition
+            stage_output_hash = clm_hash_string(
+                f"{_op}:{prev_result}"
+            )
+            store.state.inputs[f"stage{_stage}_output_hash"] = stage_output_hash
+
+            # Flush action_log for this stage to execution_log.db
+            store.flush_action_log(flush_ctx)
+
+            _logger.info(f"Pipeline stage {_stage} completed", op=_op,
+                         pcard_hash=stage_output_hash)
+            return store, 0
+
+        pipeline_store, stage_rc = pipeline_store.bind(_run_stage)
+
+        if stage_rc != 0:
+            overall_rc = stage_rc
+            break
+
+    if overall_rc == 0:
+        _logger.info("Layer 0 pipeline completed successfully")
+    else:
+        _logger.error(f"Layer 0 pipeline failed at stage {stage}")
+
+    return overall_rc