clm-kernel 0.0.9

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
{
    let mut a_mcard_opt = None;
    let has_signature = if let Some(spec) = clm_data.get("abstract_spec") {
        spec.get("signature").is_some()
    } else {
        clm_data.get("signature").is_some()
    };

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


    let mut context_val = serde_json::json!({
        "inputs": Value::Null,
        "outputs": Value::Null
    });

    if let Some(ref a_mcard) = a_mcard_opt {
        let concrete_args = get_clm_args(clm_file_str).unwrap_or_default();
        let mut inputs_map = serde_json::Map::new();

        let mut payload_parsed = false;
        if let Some(pay) = payload {
            let trimmed = pay.trim();
            if trimmed.starts_with('{') {
                if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(trimmed) {
                    for (k, v) in obj {
                        inputs_map.insert(k, v);
                    }
                    payload_parsed = true;
                }
            } else if trimmed.contains(':')
                && let Ok(data) = serde_yaml::from_str::<Value>(trimmed)
                    && let Value::Object(obj) = data {
                        for (k, v) in obj {
                            inputs_map.insert(k, v);
                        }
                        payload_parsed = true;
                    }
        }

        if !payload_parsed
            && let Some(pay) = payload
                && let Value::Object(ref sig_inputs) = a_mcard.signature.inputs
                    && sig_inputs.len() == 1 {
                        let first_key = sig_inputs.keys().next().unwrap();
                        if let Ok(num) = pay.parse::<i64>() {
                            inputs_map.insert(first_key.clone(), Value::from(num));
                        } else if let Ok(f) = pay.parse::<f64>() {
                            inputs_map.insert(first_key.clone(), Value::from(f));
                        } else if pay == "true" {
                            inputs_map.insert(first_key.clone(), Value::Bool(true));
                        } else if pay == "false" {
                            inputs_map.insert(first_key.clone(), Value::Bool(false));
                        } else {
                            inputs_map.insert(first_key.clone(), Value::String(pay.to_string()));
                        }
                    }

        if let Value::Object(ref sig_inputs) = a_mcard.signature.inputs {
            let keys: Vec<&String> = sig_inputs.keys().collect();
            for (i, key) in keys.iter().enumerate() {
                if !inputs_map.contains_key(*key)
                    && let Some(arg) = concrete_args.get(i) {
                        if let Ok(num) = arg.parse::<i64>() {
                            inputs_map.insert((*key).clone(), Value::from(num));
                        } else if let Ok(f) = arg.parse::<f64>() {
                            inputs_map.insert((*key).clone(), Value::from(f));
                        } else if arg == "true" {
                            inputs_map.insert((*key).clone(), Value::Bool(true));
                        } else if arg == "false" {
                            inputs_map.insert((*key).clone(), Value::Bool(false));
                        } else {
                            inputs_map.insert((*key).clone(), Value::String(arg.clone()));
                        }
                    }
            }
        }

        let inputs_val = Value::Object(inputs_map);
        if let Some(obj) = context_val.as_object_mut() {
            obj.insert("inputs".to_string(), inputs_val);
        }

        if !skip_conditions {
            for pre in &a_mcard.invariants.preconditions {
                match crate::invariants::evaluate_invariant(pre, clm_root_str, &context_val) {
                    Ok(true) => {
                        if !quiet {
                            eprintln!("[VCARD PRE] Invariant '{}' satisfied.", pre);
                        }
                    }
                    Ok(false) => {
                        eprintln!("[PREP_ERR] Precondition violation: Invariant '{}' failed.", pre);
                        return Ok(1);
                    }
                    Err(e) => {
                        eprintln!("[PREP_ERR] Precondition check error: Invariant '{}' raised error: {}", pre, e);
                        return Ok(1);
                    }
                }
            }
        }
    }

    let isolated_ctx = ctx.isolate(&["content_memory", "agent_identities", "execution_log"]);
    let fiber_id = format!("fiber_{}_{:x}", 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(clm_root_str, &sp_token, &["content_memory", "agent_identities"]).ok();

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

            if exit_code == 0 {
                if let Some(ref a_mcard) = a_mcard_opt {
                    let mut outputs_map = serde_json::Map::new();
                    let trimmed = output.trim();
                    let mut parsed = false;

                    if trimmed.starts_with('{') {
                        if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(trimmed) {
                            for (k, v) in obj {
                                outputs_map.insert(k, v);
                            }
                            parsed = true;
                        }
                    } else if trimmed.contains(':')
                        && let Ok(data) = serde_yaml::from_str::<Value>(trimmed)
                            && let Value::Object(obj) = data {
                                for (k, v) in obj {
                                    outputs_map.insert(k, v);
                                }
                                parsed = true;
                            }

                    if !parsed
                        && let Value::Object(ref sig_outputs) = a_mcard.signature.outputs
                            && sig_outputs.len() == 1 {
                                let first_key = sig_outputs.keys().next().unwrap();
                                if let Ok(num) = trimmed.parse::<i64>() {
                                    outputs_map.insert(first_key.clone(), Value::from(num));
                                } else if let Ok(f) = trimmed.parse::<f64>() {
                                    outputs_map.insert(first_key.clone(), Value::from(f));
                                } else if trimmed == "true" {
                                    outputs_map.insert(first_key.clone(), Value::Bool(true));
                                } else if trimmed == "false" {
                                    outputs_map.insert(first_key.clone(), Value::Bool(false));
                                } else {
                                    outputs_map.insert(first_key.clone(), Value::String(trimmed.to_string()));
                                }
                            }

                    if !outputs_map.contains_key("a_hash")
                        && let Ok(h) = std::env::var("CLM_ACTIVE_A_HASH") {
                            outputs_map.insert("a_hash".to_string(), Value::String(h));
                        }
                    if !outputs_map.contains_key("c_hash")
                        && let Ok(h) = std::env::var("CLM_ACTIVE_C_HASH") {
                            outputs_map.insert("c_hash".to_string(), Value::String(h));
                        }
                    if !outputs_map.contains_key("b_hash")
                        && let Ok(h) = std::env::var("CLM_ACTIVE_B_HASH") {
                            outputs_map.insert("b_hash".to_string(), Value::String(h));
                        }

                    if let Some(obj) = context_val.as_object_mut() {
                        obj.insert("outputs".to_string(), Value::Object(outputs_map));
                    }

                    if !skip_conditions {
                        for post in &a_mcard.invariants.postconditions {
                            match crate::invariants::evaluate_invariant(post, clm_root_str, &context_val) {
                                Ok(true) => {
                                    if !quiet {
                                        eprintln!("[VCARD POST] Invariant '{}' satisfied.", post);
                                    }
                                }
                                Ok(false) => {
                                    eprintln!("[POST_ERR] Postcondition violation: Invariant '{}' failed.", post);
                                    let _ = fiber.transition_to(crate::fiber::FiberState::Failed(format!("Postcondition violation: {}", post)));
                                    let _ = fiber.dispose();
                                    if let Some(ref mut sp) = tri_sp {
                                        let _ = sp.rollback();
                                    }
                                    return Ok(2);
                                }
                                Err(e) => {
                                    eprintln!("[POST_ERR] Postcondition check error: Invariant '{}' raised error: {}", post, e);
                                    let _ = fiber.transition_to(crate::fiber::FiberState::Failed(format!("Postcondition check error: {}", e)));
                                    let _ = fiber.dispose();
                                    if let Some(ref mut sp) = tri_sp {
                                        let _ = sp.rollback();
                                    }
                                    return Ok(2);
                                }
                            }
                        }
                    }
                }

                let raw_hex = compute_sha256_hex(output.as_bytes());
                let output_hash = format!("sha256:{}", raw_hex);
                
                let a_hash_str = clm_data.get("_meta").and_then(|m| m.get("a_hash")).and_then(|v| v.as_str())
                    .map(|s| s.to_string())
                    .unwrap_or_else(|| {
                        let spec = clm_data.get("abstract_spec").cloned().unwrap_or(serde_yaml::Value::Null);
                        let serialized = serde_yaml::to_string(&spec).unwrap_or_default();
                        format!("sha256:{}", compute_sha256_hex(serialized.replace('\r', "").as_bytes()))
                    });
                
                let c_hash_str = clm_data.get("_meta").and_then(|m| m.get("c_hash")).and_then(|v| v.as_str())
                    .map(|s| s.to_string())
                    .unwrap_or_else(|| {
                        let spec = clm_data.get("concrete_impl").cloned().unwrap_or(serde_yaml::Value::Null);
                        let serialized = serde_yaml::to_string(&spec).unwrap_or_default();
                        format!("sha256:{}", compute_sha256_hex(serialized.replace('\r', "").as_bytes()))
                    });
                
                let operation = clm_data.get("concrete_impl")
                    .and_then(|v| v.get("operation"))
                    .and_then(|v| v.as_str())
                    .unwrap_or("unknown");

                let inputs_len = clm_data.get("concrete_impl")
                    .and_then(|v| v.get("inputs"))
                    .and_then(|v| v.as_sequence())
                    .map(|a| a.len())
                    .unwrap_or(0);
                let outputs_len = clm_data.get("concrete_impl")
                    .and_then(|v| v.get("outputs"))
                    .and_then(|v| v.as_sequence())
                    .map(|a| a.len())
                    .unwrap_or(0);
                
                let x_t_d = (outputs_len as i32) - (inputs_len as i32);
                
                if !quiet {
                    eprintln!("[VCARD POST] 🔍 Noetherian P-invariant conservation check: x^T D = 0");
                }
                
                if x_t_d == 0 {
                    if !quiet {
                        eprintln!("   ✅ P-Inv: place marking conservation holds (x^T D = 0) [OK]");
                    }
                } else {
                    if !quiet {
                        eprintln!("   ⚠️ P-Inv: place marking conservation drift detected: x^T D = {} (inputs={}, outputs={})", x_t_d, inputs_len, outputs_len);
                    }
                }

                let extra_yaml = format!("content: |\n  {}", output.replace('\n', "\n  "));
                match crate::db::emit_exec_mcard(
                    operation,
                    &output_hash,
                    &extra_yaml,
                    &a_hash_str,
                    &c_hash_str,
                    clm_root_str,
                ) {
                    Ok(exec_mcard_path) => {
                        if !quiet {
                            eprintln!("[VCARD POST] ✅ Execution MCard generated: {}", exec_mcard_path);
                            eprintln!("[VCARD POST]   g_time: {}", crate::fs_utils::compute_g_time());
                            eprintln!("[VCARD POST]   content_hash: {}", raw_hex);
                        }
                    }
                    Err(e) => {
                        eprintln!("[VCARD POST] ❌ Failed to emit execution MCard: {}", e);
                    }
                }
            }

            if !skip_conditions {
                emit_gateway_trace("validate_postcondition", "post", exit_code);
                match crate::evaluator::compose::compose_conditions(clm_root, clm_file, "post", exit_code, 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)
        }
    }
}