clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use std::collections::HashMap;
use super::types::{PetriNetYaml, TransitionYaml, hash_string};
use super::token_ops::{write_marking_dir, emit_state_token, emit_state_failed, build_marking_json};
use super::sheaf_check::check_transition_sheaf_gluing;

pub struct PostTransitionArgs<'a> {
    pub exec_exit_code: i64,
    pub db_conn: &'a rusqlite::Connection,
    pub pcard_hash: &'a str,
    pub dp_hash: &'a str,
    pub final_content: &'a str,
    pub clm_root: &'a str,
    pub t: &'a TransitionYaml,
    pub place_markings: &'a mut HashMap<String, i64>,
    pub place_colors: &'a mut HashMap<String, String>,
    pub per_trans_agent_did: &'a str,
    pub is_kenotic: bool,
    pub topo_content: &'a str,
    pub net: &'a PetriNetYaml,
    pub sponsor_did: &'a str,
    pub current_marking_hash: &'a mut String,
    pub vm_ctx: &'a mut crate::cross_cutting::context::CLMContext,
    pub run_id: &'a str,
    pub input_token_hashes: &'a [String],
    pub is_visual: bool,
    pub fire_count: i64,
    pub pre_markings: &'a HashMap<String, i64>,
    pub active_p_invariants: &'a [Vec<i64>],
    pub active_p_constants: &'a [i64],
    pub place_ids: &'a [String],
    pub is_repl_trace: bool,
    pub marking_dir: &'a str,
}

fn persist_witness(final_content: &str, clm_root: &str) {
    for line in final_content.lines() {
        let trimmed = line.trim();
        if let Some(rest) = trimmed.strip_prefix("vcard_witness:") {
            let witness_hash = rest.trim().trim_matches('"').to_string();
            if !witness_hash.is_empty()
                && let Ok(cm_conn) = crate::db::get_connection(crate::layer0::vocabulary_env::PILLAR_CONTENT_MEMORY, clm_root)
            {
                let result = crate::layer0::mcard_record::MCardRecord::create(final_content.as_bytes(), None)
                    .and_then(|record| crate::layer0::record_port::RecordStorePort::insert_record(&cm_conn, &record)
                        .map(|_| record.hash).map_err(|e| e.to_string()));
                match result {
                    Ok(hash) => eprintln!("[VM] Witness persisted: {} (source claim: {})", hash, witness_hash),
                    Err(e) => eprintln!("[VM] Witness persistence failed: {}", e),
                }
            }
            break;
        }
    }
}

fn emit_kenotic_cert(args: &mut PostTransitionArgs) -> Result<(), String> {
    let topo_hash = hash_string(args.topo_content);
    let post_marking_json = build_marking_json(
        &topo_hash, &args.net.places, args.place_markings, args.place_colors,
        args.sponsor_did, args.per_trans_agent_did, args.current_marking_hash, Some(&args.t.id),
    );
    let post_marking_str = post_marking_json.to_string();
    let post_marking_hash = hash_string(&post_marking_str);

    crate::db::handle_register_batch(
        crate::layer0::vocabulary_env::PILLAR_EXECUTION_LOG, args.clm_root, &format!("run:{}:marking", args.run_id),
        &post_marking_hash, &post_marking_str,
    ).map_err(|e| e.to_string())?;

    *args.current_marking_hash = post_marking_hash.clone();
    args.vm_ctx.set_var(crate::layer0::vocabulary_env::ENV_CLM_KENOTIC_CURRENT_MARKING_HASH, &post_marking_hash);
    let _vm_ctx_guard = args.vm_ctx.enter_scope();

    let (mut vcards, mut sigs) = (Vec::new(), Vec::new());
    for h in args.input_token_hashes {
        let mut token_yaml = String::new();
        if let Some(content) = crate::db::resolve_handle_content(crate::layer0::vocabulary_env::PILLAR_CONTENT_MEMORY, args.clm_root, h).map_err(|error| error.to_string())? {
            token_yaml = content;
        } else if let Some(content) = crate::db::resolve_handle_content(crate::layer0::vocabulary_env::PILLAR_EXECUTION_LOG, args.clm_root, h).map_err(|error| error.to_string())? {
            token_yaml = content;
        } else if let Some(c) = crate::layer0::record_port::RecordStorePort::read_text(args.db_conn, h).map_err(|error| error.to_string())? {
            token_yaml = c;
        }

        if !token_yaml.is_empty()
            && let Ok(v) = serde_yaml::from_str::<serde_json::Value>(&token_yaml)
            && let Some(vcard) = v.get("vcard_token")
        {
            let agent = vcard.get("agent_did").and_then(|d| d.as_str())
                .or_else(|| vcard.get("signer_did").and_then(|d| d.as_str())).unwrap_or("");
            let sig = vcard.get("signature").and_then(|s| s.as_str()).unwrap_or(h);
            vcards.push(serde_json::json!({ "agent": agent, "vcard": h }));
            sigs.push(sig.to_string());
        }
    }

    let multi_sig = if sigs.is_empty() { "none".to_string() } else { format!("multi:{}", sigs.join(":")) };
    let cert_json = serde_json::json!({
        "@type": "TransitionCertificate",
        "run_id": args.run_id, "transition": args.t.id,
        "pcard_hash": args.pcard_hash, "vcard_hash": args.dp_hash,
        "exit_code": args.exec_exit_code, "marking_hash": args.current_marking_hash,
        "agent_did": args.per_trans_agent_did,
        "session_did": crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_SESSION_DELEGATION).unwrap_or_default(),
        "sponsor_did": crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_KENOTIC_SPONSOR_DID).unwrap_or_default(),
        "execution_locale_hash": crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_EXECUTION_LOCALE_HASH).unwrap_or_default(),
        "transport_ref": crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_TRANSPORT_REF).unwrap_or_else(|_| "local".to_string()),
        "timestamp": crate::utils::now_iso8601(), "vcards": vcards, "multi_signature": multi_sig
    }).to_string();

    let cert_hash = hash_string(&cert_json);
    crate::db::handle_register_batch(
        crate::layer0::vocabulary_env::PILLAR_EXECUTION_LOG, args.clm_root, &format!("run:{}:cert:{}", args.run_id, args.t.id),
        &cert_hash, &cert_json,
    ).map_err(|e| e.to_string())
}

fn render_visual(args: &PostTransitionArgs, out_buf: &mut String) {
    out_buf.push_str(&format!("\n  -- Step {}: Firing transition {} --\n  Places & Token Flows:\n", args.fire_count + 1, args.t.id));
    for p in &args.net.places {
        let pre_val = args.pre_markings.get(&p.id).cloned().unwrap_or(0);
        let post_val = args.place_markings.get(&p.id).cloned().unwrap_or(0);
        let emoji = match p.id.as_str() { "p0" => "📥", "p3" => "📤", _ => "◯" };
        let bullet = if post_val > 0 { "●" } else { " " };
        if pre_val != post_val {
            out_buf.push_str(&format!("    {} {:<22} [{}] ({} -> {})\n", emoji, p.id, bullet, pre_val, post_val));
        } else {
            out_buf.push_str(&format!("    {} {:<22} [{}] ({})\n", emoji, p.id, bullet, post_val));
        }
    }
    out_buf.push_str("  🔍 Live Noetherian Audits:\n");
    for (pi_idx, weights) in args.active_p_invariants.iter().enumerate() {
        let expected_val = args.active_p_constants[pi_idx];
        let mut actual_val = 0;
        let mut eq_terms = Vec::new();
        for (p_idx, &w) in weights.iter().enumerate() {
            let pid = &args.place_ids[p_idx];
            actual_val += w * args.place_markings.get(pid).cloned().unwrap_or(0);
            if w != 0 {
                let term = if w == 1 { pid.clone() } else if w == -1 { format!("-{}", pid) } else { format!("{}*{}", w, pid) };
                eq_terms.push(term);
            }
        }
        let eq_str = eq_terms.join(" + ").replace("+ -", "- ");
        if actual_val == expected_val {
            out_buf.push_str(&format!("     ✅ P-Inv #{}: {} = {} [OK]\n", pi_idx, eq_str, expected_val));
        } else {
            out_buf.push_str(&format!("     ❌ P-Inv #{}: {} = {} (expected {}) [FAIL]\n", pi_idx, eq_str, actual_val, expected_val));
        }
    }
}

fn render_repl_trace(args: &PostTransitionArgs, out_buf: &mut String) {
    let mut json_places = serde_json::Map::new();
    for p in &args.net.places {
        let val = args.place_markings.get(&p.id).cloned().unwrap_or(0);
        json_places.insert(p.id.clone(), serde_json::Value::Number(val.into()));
    }
    let pinv_held = if !args.active_p_invariants.is_empty() {
        let pi0 = &args.active_p_invariants[0];
        let mut actual = 0;
        for (p_idx, &w) in pi0.iter().enumerate() {
            actual += w * args.place_markings.get(&args.place_ids[p_idx]).cloned().unwrap_or(0);
        }
        actual == args.active_p_constants[0]
    } else {
        true
    };

    let trace_json = serde_json::json!({
        "type": "trace", "transition": args.t.id, "agent": args.per_trans_agent_did,
        "agent_class": if args.per_trans_agent_did.starts_with(crate::layer0::vocabulary_identities::DID_KEY) { "EOA" } else { "CA" },
        "sponsor": args.sponsor_did, "pcard": args.pcard_hash, "cert": args.dp_hash,
        "merkle": args.current_marking_hash, "places": json_places, "pinv_held": pinv_held
    }).to_string();

    out_buf.push_str(&format!("CLM_TRACE_JSON:{}\n\n===============================================================\n  REPL Cycle {}: {}\n===============================================================\n", trace_json, args.fire_count + 1, args.t.id));
    out_buf.push_str(&format!(
        "  ┌- READ --------------------------------------------------------\n  │  Agent:    {} {}\n  │  Sponsor:  {}\n  └---------------------------------------------------------------\n",
        if args.per_trans_agent_did.starts_with(crate::layer0::vocabulary_identities::DID_KEY) { "👤" } else { "🤖" }, args.per_trans_agent_did, args.sponsor_did
    ));
}

pub fn handle_post_transition(
    mut args: PostTransitionArgs,
    sync_sqlite: impl Fn(&HashMap<String, i64>, &HashMap<String, String>) -> Result<(), String>,
    out_buf: &mut String,
) -> Result<(), String> {
    if args.exec_exit_code == 0 {
        let _state_hash = emit_state_token(args.db_conn, args.pcard_hash, args.dp_hash, args.final_content, args.clm_root)?;
        check_transition_sheaf_gluing(args.t, args.place_colors, args.final_content, args.per_trans_agent_did, args.db_conn)?;

        if args.final_content.contains("vcard_witness:") {
            out_buf.push_str(args.final_content);
            if !args.final_content.ends_with('\n') {
                out_buf.push('\n');
            }
            persist_witness(args.final_content, args.clm_root);
        }

        for outp in &args.t.outputs {
            if let Some(cur) = args.place_markings.get_mut(outp) {
                *cur += 1;
            }
            args.place_colors.insert(outp.clone(), args.final_content.to_string());
        }
        sync_sqlite(args.place_markings, args.place_colors)?;

        for outp in &args.t.outputs {
            let tok = args.place_markings.get(outp).cloned().unwrap_or(0);
            write_marking_dir(args.marking_dir, outp, tok, Some(args.final_content));
        }

        if args.is_kenotic {
            emit_kenotic_cert(&mut args)?;
        }
        if args.is_visual {
            render_visual(&args, out_buf);
        }
        if args.is_repl_trace {
            render_repl_trace(&args, out_buf);
        }

        for (pi_idx, weights) in args.active_p_invariants.iter().enumerate() {
            let expected_val = args.active_p_constants[pi_idx];
            let mut actual_val = 0;
            for (p_idx, &w) in weights.iter().enumerate() {
                let pid = &args.place_ids[p_idx];
                actual_val += w * args.place_markings.get(pid).cloned().unwrap_or(0);
            }
            if actual_val != expected_val {
                out_buf.push_str("  ❌ [NOETHER_ERR] P-Invariant Safety Violation!\n");
                emit_state_failed(args.pcard_hash, 1, "P-Invariant Safety Violation", args.clm_root)?;
                return Err(out_buf.clone());
            }
        }
    } else {
        out_buf.push_str(&format!("❌ [ERROR] Transition {} failed with exit_code={}\n", args.t.id, args.exec_exit_code));
        emit_state_failed(args.pcard_hash, args.exec_exit_code, &format!("Transition {} failed", args.t.id), args.clm_root)?;
    }
    Ok(())
}