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)
}
}
}