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("content_memory", clm_root)
{
let ts = crate::fs_utils::compute_g_time();
match cm_conn.execute(
"INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?)",
rusqlite::params![witness_hash, final_content, ts],
) {
Ok(updated) => eprintln!("[VM] ✅ Witness persisted: {} (rows: {})", witness_hash, updated),
Err(e) => eprintln!("[VM] ❌ Witness persistence failed: {} - Error: {}", witness_hash, 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(
"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("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 Ok(Some(content)) = crate::db::resolve_handle_content("content_memory", args.clm_root, h) {
token_yaml = content;
} else if let Ok(Some(content)) = crate::db::resolve_handle_content("execution_log", args.clm_root, h) {
token_yaml = content;
} else if let Ok(c) = args.db_conn.query_row("SELECT content FROM card WHERE hash = ?", rusqlite::params![h], |row| row.get(0)) {
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": std::env::var("CLM_SESSION_DELEGATION").unwrap_or_default(),
"sponsor_did": std::env::var("CLM_KENOTIC_SPONSOR_DID").unwrap_or_default(),
"execution_locale_hash": std::env::var("CLM_EXECUTION_LOCALE_HASH").unwrap_or_default(),
"transport_ref": std::env::var("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(
"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("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("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(())
}