clm-kernel 0.0.15

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use std::path::Path;
use super::InternalFn;
use super::runtime;
use super::orchestrator_invariants::{
    prepare_context_inputs_and_check_preconditions,
    parse_outputs_and_check_postconditions,
    check_noether_and_emit_exec_mcard,
};

pub(super) struct PipelineArgs<'a> {
    pub ctx: &'a crate::fiber::Context,
    pub clm_root: &'a Path,
    pub clm_file: &'a str,
    pub payload: Option<&'a str>,
    pub post_rc: Option<i32>,
    pub quiet: bool,
    pub clm_data: &'a serde_yaml::Value,
    pub concrete_impl: &'a serde_yaml::Value,
    pub operation: &'a str,
    pub is_rust: bool,
    pub registered_func: Option<InternalFn>,
    pub module_path_opt: Option<&'a str>,
    pub process_type: &'a str,
    pub runtime_str: &'a str,
    pub skip_conditions: bool,
    pub clm_root_str: &'a str,
    pub clm_file_str: &'a str,
}

pub(super) fn execute_orchestrator_pipeline(
    args: PipelineArgs,
    emit_gateway_trace: impl Fn(&str, &str, i32),
) -> Result<i32, String> {
    let mut a_mcard_opt = None;
    let has_signature = if let Some(spec) = args.clm_data.get("abstract_spec") {
        spec.get("signature").is_some()
    } else {
        args.clm_data.get("signature").is_some()
    };

    if has_signature {
        match crate::parser::parse_a_mcard(args.clm_file_str) {
            Ok(a) => a_mcard_opt = Some(a),
            Err(e) if !args.quiet => {
                eprintln!("[clmEval-rs] ⚠️ Warning: Failed to parse A-MCard spec for validation: {}", e);
            }
            _ => {}
        }
    }

    let mut context_val = serde_json::json!({ "inputs": serde_json::Value::Null, "outputs": serde_json::Value::Null });
    if let Some(ref a_mcard) = a_mcard_opt {
        let concrete_args = super::get_clm_args(args.clm_file_str).unwrap_or_default();
        match prepare_context_inputs_and_check_preconditions(
            a_mcard, &concrete_args, args.payload, args.skip_conditions, args.clm_root_str, args.quiet,
        ) {
            Ok(ctx) => context_val = ctx,
            Err(_) => return Ok(1),
        }
    }

    let isolated_ctx = args.ctx.isolate(&["content_memory", "agent_identities", "execution_log"]);
    let fiber_id = format!("fiber_{}_{:x}", args.clm_file.replace(['/', '.'], "_"), rand::random::<u16>());
    let fiber = isolated_ctx.spawn_fiber(&fiber_id, vec![]);
    let _ = fiber.transition_to(crate::fiber::FiberState::Active);

    let sp_token = format!("sp_{}_{:x}", std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0), rand::random::<u32>());
    let mut tri_sp = crate::fiber::disposable::TriDbSavepointGuard::with_pillars(args.clm_root_str, &sp_token, &["content_memory", "agent_identities"]).ok();

    emit_gateway_trace(&format!("execute:{}", args.operation), "exec", 0);
    let run_res = if args.is_rust {
        match args.registered_func {
            Some(f) => f(args.clm_root_str, args.clm_file_str),
            None => {
                let m_path = args.module_path_opt.unwrap_or("");
                if !args.quiet {
                    eprintln!("[clmEval-rs] ⚡ Sourcing shell test fallback for unregistered module: {}", m_path);
                }
                runtime::run_fallback_internal_reference(args.clm_root_str, args.clm_file_str, m_path, args.quiet)
            }
        }
    } else {
        runtime::evaluate_non_rust_runtime(args.clm_root, args.clm_file, args.process_type, args.runtime_str, args.concrete_impl, args.payload, args.post_rc, args.quiet)
    };

    match run_res {
        Ok((exit_code, output)) => {
            let nested_exec = crate::cross_cutting::context::CLMContext::get_scoped_or_env("CLM_NESTED_EXEC").unwrap_or_default() == "1";
            let is_user_script = !args.is_rust && !args.operation.starts_with("test_");
            if !output.is_empty() && (!args.quiet || nested_exec || is_user_script) {
                print!("{}", output);
            }

            if exit_code == 0 {
                if let Some(ref a_mcard) = a_mcard_opt {
                    if parse_outputs_and_check_postconditions(
                        a_mcard, &output, &mut context_val, args.skip_conditions, args.clm_root_str, args.quiet,
                    ).is_err() {
                        let _ = fiber.transition_to(crate::fiber::FiberState::Failed("Postcondition violation".to_string()));
                        let _ = fiber.dispose();
                        if let Some(ref mut sp) = tri_sp { let _ = sp.rollback(); }
                        return Ok(2);
                    }
                }
                check_noether_and_emit_exec_mcard(args.operation, &output, args.clm_data, args.clm_root_str, args.quiet);
            }

            if !args.skip_conditions {
                emit_gateway_trace("validate_postcondition", "post", exit_code);
                match crate::evaluator::compose::compose_conditions(args.clm_root, args.clm_file, "post", exit_code, args.quiet) {
                    Ok(0) => {}
                    Ok(rc) => {
                        eprintln!("CRITICAL: Post-Gate Failed.");
                        let _ = fiber.transition_to(crate::fiber::FiberState::Failed("Post-Gate Failed".to_string()));
                        let _ = fiber.dispose();
                        if let Some(ref mut sp) = tri_sp { let _ = sp.rollback(); }
                        return Ok(rc);
                    }
                    Err(e) if e.contains("SovereignSubprocessForbiddenError") => {
                        let _ = fiber.transition_to(crate::fiber::FiberState::Failed(format!("Post-Gate Failed: {}", e)));
                        let _ = fiber.dispose();
                        if let Some(ref mut sp) = tri_sp { let _ = sp.rollback(); }
                        return Err(e);
                    }
                    Err(e) => {
                        eprintln!("CRITICAL: Post-Gate Failed: {}", e);
                        let _ = fiber.transition_to(crate::fiber::FiberState::Failed(format!("Post-Gate Failed: {}", e)));
                        let _ = fiber.dispose();
                        if let Some(ref mut sp) = tri_sp { let _ = sp.rollback(); }
                        return Ok(2);
                    }
                }
            }

            if let Some(ref mut sp) = tri_sp {
                if exit_code == 0 { let _ = sp.commit(); } else { let _ = sp.rollback(); }
            }

            if exit_code == 0 {
                let _ = fiber.dispose();
            } else {
                let _ = fiber.transition_to(crate::fiber::FiberState::Failed(format!("Exit code {}", exit_code)));
                let _ = fiber.dispose();
            }

            emit_gateway_trace("vcard_seal", "seal", exit_code);
            Ok(exit_code)
        }
        Err(e) if e.contains("SovereignSubprocessForbiddenError") => {
            let _ = fiber.transition_to(crate::fiber::FiberState::Failed(format!("Internal dispatch error: {}", e)));
            let _ = fiber.dispose();
            if let Some(ref mut sp) = tri_sp { let _ = sp.rollback(); }
            Err(e)
        }
        Err(e) => {
            eprintln!("[clmEval-rs] ❌ Internal dispatch error: {}", e);
            let _ = fiber.transition_to(crate::fiber::FiberState::Failed(format!("Internal dispatch error: {}", e)));
            let _ = fiber.dispose();
            if let Some(ref mut sp) = tri_sp { let _ = sp.rollback(); }
            Ok(1)
        }
    }
}