clm-kernel 0.0.18

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
pub use super::formal_contract::*;
pub use crate::layer1::formal_witness::*;

#[cfg(feature = "native")]
mod native_exec {
    use super::*;
    use std::collections::{HashMap, HashSet};
    use std::io::{Read, Write};
    use std::path::{Path, PathBuf};
    use std::process::{Command, Stdio};
    use std::sync::{atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}, mpsc, Arc};
    use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

    const MAX_FORMAL_OUTPUT_BYTES: usize = 1_048_576;
    static WORK_DIR_SEQ: AtomicU64 = AtomicU64::new(0);
    /// Result returned when dispatching a formal oracle run through native Rust execution.
    #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
    pub struct FormalDispatchOutcome {
        pub exit_code: i32, pub stdout: String, pub stderr: String, pub witness: OracleWitness,
    }

    /// Toolchain probe outcome reported by `probe_formal_runtime`.
    #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
    pub struct FormalProbeReport {
        pub runtime_id: String, pub profile_id: String, pub available: bool, pub timed_out: bool,
        pub executable_path: Option<String>, pub toolchain_version: String, pub runner_used: bool,
    }

    enum BoundedRunOutcome { Completed { exit_code: i32, stdout: Vec<u8>, stderr: Vec<u8> }, TimedOut, OutputCapExceeded }
    enum ProbeResolution { Found { exe_path: PathBuf, version_line: String, jar_path: Option<String> }, TimedOut, Unavailable }
    fn kill_child_tree(child: &mut std::process::Child) {
        #[cfg(unix)] { let _ = Command::new("/bin/kill").args(["-9", &format!("-{}", child.id())]).stdout(Stdio::null()).stderr(Stdio::null()).status(); }
        let _ = child.kill(); let _ = child.wait();
    }
fn spawn_reader<R: Read + Send + 'static>(mut stream: R, total: Arc<AtomicUsize>, exceeded: Arc<AtomicBool>, cap: usize) -> mpsc::Receiver<Vec<u8>> {
        let (tx, rx) = mpsc::sync_channel(1);
        std::thread::spawn(move || {
            let (mut buf, mut chunk) = (Vec::new(), [0u8; 8192]);
            while let Ok(n) = stream.read(&mut chunk) {
                if n == 0 { break; }
                if total.fetch_add(n, Ordering::SeqCst) + n > cap { exceeded.store(true, Ordering::SeqCst); break; }
                buf.extend_from_slice(&chunk[..n]);
            }
            let _ = tx.send(buf);
        });
        rx
    }

    fn spawn_bounded(
        executable: &Path, args: &[String], cwd: Option<&Path>, env: &HashMap<String, String>,
        stdin_bytes: Option<&[u8]>, timeout_ms: u64, max_output_bytes: usize,
    ) -> Result<BoundedRunOutcome, String> {
        let mut cmd = Command::new(executable);
        cmd.args(args).env_clear().envs(env).stdout(Stdio::piped()).stderr(Stdio::piped());
        cmd.stdin(if stdin_bytes.is_some() { Stdio::piped() } else { Stdio::null() });
        if let Some(dir) = cwd { cmd.current_dir(dir); }
        #[cfg(unix)]
        { use std::os::unix::process::CommandExt; cmd.process_group(0); }
        let mut child = cmd.spawn().map_err(|e| format!("Failed to spawn {}: {}", executable.display(), e))?;
        if let (Some(bytes), Some(mut child_in)) = (stdin_bytes.map(|b| b.to_vec()), child.stdin.take()) {
            std::thread::spawn(move || { let _ = child_in.write_all(&bytes); });
        }
        let (total, exceeded) = (Arc::new(AtomicUsize::new(0)), Arc::new(AtomicBool::new(false)));
        let out_rx = spawn_reader(child.stdout.take().unwrap(), Arc::clone(&total), Arc::clone(&exceeded), max_output_bytes);
        let err_rx = spawn_reader(child.stderr.take().unwrap(), Arc::clone(&total), Arc::clone(&exceeded), max_output_bytes);
        let deadline = Instant::now() + Duration::from_millis(timeout_ms);
        loop {
            if exceeded.load(Ordering::SeqCst) { kill_child_tree(&mut child); return Ok(BoundedRunOutcome::OutputCapExceeded); }
            if let Some(status) = child.try_wait().map_err(|e| e.to_string())? {
                let stdout = out_rx.recv_timeout(Duration::from_millis(250)).unwrap_or_default();
                let stderr = err_rx.recv_timeout(Duration::from_millis(250)).unwrap_or_default();
                if exceeded.load(Ordering::SeqCst) || stdout.len() + stderr.len() > max_output_bytes {
                    return Ok(BoundedRunOutcome::OutputCapExceeded);
                }
                return Ok(BoundedRunOutcome::Completed { exit_code: status.code().unwrap_or(1), stdout, stderr });
            }
            if Instant::now() >= deadline { kill_child_tree(&mut child); return Ok(BoundedRunOutcome::TimedOut); }
            std::thread::sleep(Duration::from_millis(5));
        }
    }

    fn candidate_search_dirs(sanitized_env: &HashMap<String, String>, include_fallbacks: bool) -> Vec<PathBuf> {
        let mut raw = Vec::new();
        if let Some(p) = sanitized_env.get("PATH") { raw.extend(std::env::split_paths(p).filter(|d| !d.as_os_str().is_empty())); }
        if let Some(elan) = sanitized_env.get("ELAN_HOME") { raw.push(PathBuf::from(elan).join("bin")); }
        if let Some(jh) = sanitized_env.get("JAVA_HOME") { raw.push(PathBuf::from(jh).join("bin")); }
        if include_fallbacks {
            let home = sanitized_env.get("HOME").map(PathBuf::from).or_else(|| std::env::var_os("HOME").map(PathBuf::from));
            if let Some(ref h) = home {
                raw.push(h.join(".elan/bin"));
                if let Ok(entries) = std::fs::read_dir(h.join(".opam")) {
                    let mut sw: Vec<PathBuf> = entries.flatten().map(|e| e.path().join("bin")).filter(|p| p.is_dir()).collect();
                    sw.sort();
                    raw.extend(sw);
                }
            }
            raw.push(PathBuf::from("/opt/homebrew/bin"));
            if let Some(ref h) = home { raw.push(h.join(".local/bin")); }
        }
        let mut seen = HashSet::new();
        raw.into_iter().filter(|d| seen.insert(d.clone())).collect()
    }

    fn probe_matches(
        cand: &Path, args: &[String], allow_nonzero: bool, subs_all: &[String], subs_any: &[String],
        env: &HashMap<String, String>, timeout_ms: u64,
    ) -> Result<Option<String>, ()> {
        let probe_cwd = std::env::temp_dir();
        match spawn_bounded(cand, args, Some(&probe_cwd), env, None, timeout_ms, MAX_FORMAL_OUTPUT_BYTES) {
            Ok(BoundedRunOutcome::TimedOut) => Err(()),
            Ok(BoundedRunOutcome::Completed { exit_code, stdout, stderr }) if allow_nonzero || exit_code == 0 => {
                let combined = format!("{}\n{}", String::from_utf8_lossy(&stdout), String::from_utf8_lossy(&stderr));
                if subs_all.iter().all(|s| combined.contains(s)) && (subs_any.is_empty() || subs_any.iter().any(|s| combined.contains(s))) {
                    return Ok(Some(combined.lines().find(|l| !l.trim().is_empty()).unwrap_or("").trim().to_string()));
                }
                Ok(None)
            }
            _ => Ok(None),
        }
    }

    fn scan_dirs_for_exe(dirs: &[PathBuf], exe: &str, args: &[String], nz: bool, sall: &[String], sany: &[String], env: &HashMap<String, String>, tms: u64) -> Result<Option<(PathBuf, String)>, ()> {
        for dir in dirs {
            let cand = dir.join(exe);
            if cand.is_file() { if let Some(ver) = probe_matches(&cand, args, nz, sall, sany, env, tms)? { return Ok(Some((cand, ver))); } }
        }
        Ok(None)
    }
fn resolve_toolchain(target: &ResolvedFormalTarget, sanitized_env: &HashMap<String, String>, include_fallbacks: bool) -> ProbeResolution {
        let dirs = candidate_search_dirs(sanitized_env, include_fallbacks);
        match scan_dirs_for_exe(&dirs, &target.executable, &target.probe_args, target.allow_nonzero_probe, &target.version_substrings_all, &target.version_substrings_any, sanitized_env, target.probe_timeout_ms) {
            Err(()) => return ProbeResolution::TimedOut,
            Ok(Some((exe_path, version_line))) => return ProbeResolution::Found { exe_path, version_line, jar_path: None },
            Ok(None) => {}
        }
        let Some(ref runner) = target.runner else { return ProbeResolution::Unavailable; };
        let home = sanitized_env.get("HOME").map(PathBuf::from).or_else(|| if include_fallbacks { std::env::var_os("HOME").map(PathBuf::from) } else { None });
        let jar_opt = sanitized_env.get("TLA2TOOLS_JAR").map(PathBuf::from).filter(|p| p.is_file())
            .or_else(|| target.default_jar_relpath.as_ref().and_then(|rel| home.as_ref().map(|h| h.join(rel))).filter(|p| p.is_file()))
            .or_else(|| home.as_ref().map(|h| h.join(".local/share/tlaplus/tla2tools-1.8.0.jar")).filter(|p| p.is_file()));
        let (Some(jar_path), Some(rt_lock)) = (jar_opt, target.lock_runtimes.get(&runner.runtime_id)) else { return ProbeResolution::Unavailable; };
        let Some(profs_obj) = rt_lock.get("profiles").and_then(|v| v.as_object()) else { return ProbeResolution::Unavailable; };
        let def_p = rt_lock.get("default_profile").and_then(|v| v.as_str()).unwrap_or_default();
        let mut order: Vec<&str> = if profs_obj.contains_key(def_p) { vec![def_p] } else { Vec::new() };
        order.extend(profs_obj.keys().map(String::as_str).filter(|k| *k != def_p));
        let mut java_exe = None;
        for pk in order {
            let pl = &profs_obj[pk];
            let exe = pl.get("executable").and_then(|v| v.as_str()).unwrap_or_default();
            match scan_dirs_for_exe(&dirs, exe, &json_str_vec(pl.get("probe_args")), pl.get("allow_nonzero_probe").and_then(|v| v.as_bool()).unwrap_or(false), &json_str_vec(pl.get("version_substrings_all")), &json_str_vec(pl.get("version_substrings_any")), sanitized_env, target.probe_timeout_ms) {
                Err(()) => return ProbeResolution::TimedOut,
                Ok(Some((cand, _))) => { java_exe = Some(cand); break; }
                Ok(None) => {}
            }
        }
        let Some(j_exe) = java_exe else { return ProbeResolution::Unavailable; };
        let jar_str = jar_path.to_string_lossy().into_owned();
        let jar_args = vec!["-cp".to_string(), jar_str.clone(), "tlc2.TLC".to_string(), "-version".to_string()];
        match probe_matches(&j_exe, &jar_args, target.allow_nonzero_probe, &target.version_substrings_all, &target.version_substrings_any, sanitized_env, target.probe_timeout_ms) {
            Err(()) => ProbeResolution::TimedOut,
            Ok(Some(version_line)) => ProbeResolution::Found { exe_path: j_exe, version_line, jar_path: Some(jar_str) },
            Ok(None) => ProbeResolution::Unavailable,
        }
    }

    fn seal_outcome(t: &ResolvedFormalTarget, status: OracleWitnessStatus, source_digest: String, theorem_digest: String, toolchain_version: String, argv: Vec<String>, result_digest: String, diagnostic_digest: String, stderr: String) -> FormalDispatchOutcome {
        let exit_code = match status { OracleWitnessStatus::Verified | OracleWitnessStatus::SkippedUnavailable => 0, _ => 1 };
        let witness = build_oracle_witness(OracleWitnessInput { runtime_id: t.canonical_id.clone(), profile_id: t.active_profile.clone(), status, source_digest, theorem_digest, toolchain_version, argv, env_allowlist: t.env_allowlist.clone(), result_digest, diagnostic_digest });
        FormalDispatchOutcome { exit_code, stdout: serde_json::to_string(&witness).unwrap_or_default(), stderr, witness }
    }
    fn seal_terminal(t: &ResolvedFormalTarget, st: OracleWitnessStatus, sd: String, td: String, ver: String, argv: Vec<String>, tag: &str) -> FormalDispatchOutcome {
        seal_outcome(t, st, sd, td, ver, argv, compute_formal_blake3(b""), compute_formal_blake3(tag.as_bytes()), tag.to_string())
    }
    /// List all admitted formal runtimes and their profiles from `schema/runtime_types.json`.
    pub fn list_formal_runtimes(explicit_clm_root: &str) -> Result<Vec<FormalRuntimeSummary>, String> {
        load_formal_runtime_summaries(explicit_clm_root)
    }

    /// Probe a formal runtime profile under bounded timeout and optional `runner` indirection.
    pub fn probe_formal_runtime(
        runtime_id: &str, profile_id: Option<&str>, caller_env: Option<&HashMap<String, String>>,
        include_system_fallbacks: bool, explicit_clm_root: &str,
    ) -> Result<FormalProbeReport, String> {
        let target = resolve_formal_target(runtime_id, profile_id, None, None, explicit_clm_root)?;
        let (sanitized_env, _) = sanitize_env_and_strict(false, false, &target.env_allowlist, caller_env);
        let (available, timed_out, executable_path, toolchain_version, runner_used) = match resolve_toolchain(&target, &sanitized_env, include_system_fallbacks) {
            ProbeResolution::Found { exe_path, version_line, jar_path } => (true, false, Some(exe_path.to_string_lossy().into_owned()), version_line, jar_path.is_some()),
            ProbeResolution::TimedOut => (false, true, None, "timeout".to_string(), false),
            ProbeResolution::Unavailable => (false, false, None, "unavailable".to_string(), false),
        };
        Ok(FormalProbeReport {
            runtime_id: target.canonical_id, profile_id: target.active_profile, available, timed_out,
            executable_path, toolchain_version, runner_used,
        })
    }

    /// Execute a `FormalExecutionRequest` per `clm.formal.execution.contract.v1`.
    pub fn execute_formal_request(
        request: &FormalExecutionRequest, caller_env: Option<&HashMap<String, String>>,
    ) -> Result<FormalDispatchOutcome, String> {
        let target = resolve_formal_target(&request.runtime_id, request.profile_id.as_deref(), request.timeout_ms, request.probe_timeout_ms, &request.clm_root)?;
        if let Some(bad) = request.staged_files.keys().find(|k| !is_bare_filename(k)) {
            return Err(format!("Invalid staged_files key: {}", bad));
        }
        if request.source_file.as_deref().is_some_and(|s| !s.is_empty()) == request.source_text.is_some() {
            return Err("Provide exactly one of source_file or source_text".to_string());
        }
        let (sanitized_env, is_strict) = sanitize_env_and_strict(request.strict, request.isolated_empty_path, &target.env_allowlist, caller_env);
        let resolve_rel = |raw: &str| -> PathBuf {
            let p = Path::new(raw);
            if p.is_absolute() || (!target.clm_root.join(p).is_file() && p.is_file()) { p.to_path_buf() } else { target.clm_root.join(p) }
        };

        let (staged_basename, raw_bytes, sf_disk_opt) = if let Some(sf_str) = request.source_file.as_deref().filter(|s| !s.is_empty()) {
            let base = Path::new(sf_str).file_name().and_then(|n| n.to_str()).filter(|n| is_bare_filename(n))
                .ok_or_else(|| format!("Invalid source_file basename: {}", sf_str))?.to_string();
            let sf_path = resolve_rel(sf_str);
            if !sf_path.is_file() {
                let (empty_dig, stem) = (compute_formal_blake3(b""), file_stem_label(&base));
                let thm_lbl = request.theorem_name.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
                let thm_dig = compute_formal_blake3(format!("{}:{}:{}:{}", target.canonical_id, target.active_profile, thm_lbl, empty_dig).as_bytes());
                let ep = request.entry_point.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
                let argv = expand_canonical_argv(&target.argv_template, &target.config_args_template, &base, ep, None, None, &request.extra_args, &request.trailing_args);
                return Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, empty_dig, thm_dig, "missing_source".to_string(), argv, "source_file_missing"));
            }
            (base, std::fs::read(&sf_path).map_err(|e| e.to_string())?, Some(sf_path))
        } else {
            let sn = request.source_name.as_deref().filter(|n| is_bare_filename(n))
                .ok_or_else(|| "source_name must be a valid bare filename when source_text is supplied".to_string())?;
            (sn.to_string(), request.source_text.as_deref().unwrap_or_default().as_bytes().to_vec(), None)
        };

        let stem = file_stem_label(&staged_basename);
        let thm_lbl = request.theorem_name.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
        let source_digest = compute_formal_blake3(&raw_bytes);
        let theorem_digest = compute_formal_blake3(format!("{}:{}:{}:{}", target.canonical_id, target.active_profile, thm_lbl, source_digest).as_bytes());

        let (staged_cfg_name, cfg_disk_path) = if let Some(cf) = request.config_file.as_deref().filter(|s| !s.is_empty()) {
            let cf_base = Path::new(cf).file_name().and_then(|n| n.to_str()).unwrap_or_default();
            if !cf_base.is_empty() && request.staged_files.contains_key(cf_base) { (Some(cf_base.to_string()), None) }
            else { let cp = resolve_rel(cf); if cp.is_file() { (cp.file_name().and_then(|n| n.to_str()).map(String::from), Some(cp)) } else { (None, None) } }
        } else if let Some(sib) = sf_disk_opt.as_ref().map(|p| p.with_extension("cfg")).filter(|p| p.is_file()) {
            (sib.file_name().and_then(|n| n.to_str()).map(String::from), Some(sib))
        } else { (None, None) };

        let entry_pt = request.entry_point.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
        let mut canonical_argv = expand_canonical_argv(&target.argv_template, &target.config_args_template, &staged_basename, entry_pt, staged_cfg_name.as_deref(), None, &request.extra_args, &request.trailing_args);

        let (exe_path, version_line, active_tpl) = match resolve_toolchain(&target, &sanitized_env, request.include_system_fallbacks && !request.isolated_empty_path) {
            ProbeResolution::TimedOut => return Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, source_digest, theorem_digest, "timeout".to_string(), canonical_argv, "timeout")),
            ProbeResolution::Unavailable => {
                let st = if is_strict { OracleWitnessStatus::Refuted } else { OracleWitnessStatus::SkippedUnavailable };
                return Ok(seal_terminal(&target, st, source_digest, theorem_digest, "unavailable".to_string(), canonical_argv, "toolchain_unavailable"));
            }
            ProbeResolution::Found { exe_path, version_line, jar_path } => {
                if let (Some(jar), Some(runner)) = (jar_path.as_deref(), target.runner.as_ref()) {
                    canonical_argv = expand_canonical_argv(&runner.argv_template, &target.config_args_template, &staged_basename, entry_pt, staged_cfg_name.as_deref(), Some(jar), &request.extra_args, &request.trailing_args);
                    (exe_path, version_line, &runner.argv_template)
                } else { (exe_path, version_line, &target.argv_template) }
            }
        };

        let nonce = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
        let work_dir = std::env::temp_dir().join(format!("clm_formal_{}_{}_{}", std::process::id(), nonce, WORK_DIR_SEQ.fetch_add(1, Ordering::Relaxed)));
        std::fs::create_dir_all(&work_dir).map_err(|e| e.to_string())?;
        std::fs::write(work_dir.join(&staged_basename), &raw_bytes).map_err(|e| e.to_string())?;
        for (fname, body) in &request.staged_files { std::fs::write(work_dir.join(fname), body.as_bytes()).map_err(|e| e.to_string())?; }
        if let (Some(cfg_n), Some(cfg_p)) = (staged_cfg_name.as_deref(), cfg_disk_path.as_deref()) {
            if !request.staged_files.contains_key(cfg_n) { std::fs::copy(cfg_p, work_dir.join(cfg_n)).map_err(|e| e.to_string())?; }
        }
        if active_tpl.iter().any(|t| t.contains("{output_dir}")) { std::fs::create_dir_all(work_dir.join("classes")).map_err(|e| e.to_string())?; }
        let real_work = std::fs::canonicalize(&work_dir).map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
        let raw_work = work_dir.to_string_lossy().into_owned();

        let run_res = spawn_bounded(&exe_path, &canonical_argv[1..], Some(&work_dir), &sanitized_env, request.stdin_text.as_deref().map(str::as_bytes), target.timeout_ms, MAX_FORMAL_OUTPUT_BYTES);
        let _ = std::fs::remove_dir_all(&work_dir);

        match run_res? {
            BoundedRunOutcome::TimedOut => Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, source_digest, theorem_digest, version_line, canonical_argv, "timeout")),
            BoundedRunOutcome::OutputCapExceeded => Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, source_digest, theorem_digest, version_line, canonical_argv, "output_cap_exceeded")),
            BoundedRunOutcome::Completed { exit_code, stdout, stderr } => {
                let norm_out = normalize_formal_output(&String::from_utf8_lossy(&stdout), &real_work, &raw_work, &target.nondeterministic_line_patterns, &target.nondeterministic_inline_patterns)?;
                let norm_err = normalize_formal_output(&String::from_utf8_lossy(&stderr), &real_work, &raw_work, &target.nondeterministic_line_patterns, &target.nondeterministic_inline_patterns)?;
                let accepted = evaluate_accept_predicate(&target.accept_predicate, exit_code, &norm_out, &norm_err, &String::from_utf8_lossy(&raw_bytes))?;
                let status = if accepted { OracleWitnessStatus::Verified } else { OracleWitnessStatus::Refuted };
                let (res_dig, diag_dig) = (compute_formal_blake3(norm_out.as_bytes()), compute_formal_blake3(format!("{}\n{}", norm_out, norm_err).as_bytes()));
                Ok(seal_outcome(&target, status, source_digest, theorem_digest, version_line, canonical_argv, res_dig, diag_dig, if norm_err.is_empty() { norm_out } else { norm_err }))
            }
        }
    }

    pub fn dispatch_formal_runtime_script(
        runtime_alias: &str, script: &str, profile_override: &str, extra_args: &[String],
        caller_env: &HashMap<String, String>, explicit_clm_root: &str,
    ) -> Result<FormalDispatchOutcome, String> {
        let target = resolve_formal_target(runtime_alias, Some(profile_override).filter(|s| !s.is_empty()), None, None, explicit_clm_root)?;
        let (source_file, source_text, source_name, rem_args) = if !script.is_empty() {
            (None, Some(script.to_string()), Some(format!("Spec{}", target.default_extension)), extra_args.to_vec())
        } else if let Some((first, rest)) = extra_args.split_first() {
            (Some(first.clone()), None, None, rest.to_vec())
        } else {
            return Err("Formal oracle requires script content or source file path".to_string());
        };
        let req = FormalExecutionRequest {
            runtime_id: runtime_alias.to_string(),
            profile_id: if profile_override.is_empty() { None } else { Some(profile_override.to_string()) },
            source_file, source_text, source_name, extra_args: rem_args,
            clm_root: explicit_clm_root.to_string(), ..Default::default()
        };
        execute_formal_request(&req, if caller_env.is_empty() { None } else { Some(caller_env) })
    }
}

#[cfg(feature = "native")]
pub use native_exec::*;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_oracle_witness_four_state() {
        let golden = build_oracle_witness(OracleWitnessInput {
            runtime_id: "lean".to_string(), profile_id: "lean_4_35".to_string(), status: OracleWitnessStatus::Verified,
            source_digest: "blake3:1111111111111111111111111111111111111111111111111111111111111111".to_string(),
            theorem_digest: "blake3:2222222222222222222222222222222222222222222222222222222222222222".to_string(),
            toolchain_version: "Lean (version 4.35.0)".to_string(),
            argv: vec!["lean".to_string(), "--json".to_string(), "OpenPetriPullback.lean".to_string()],
            env_allowlist: vec!["PATH".to_string(), "HOME".to_string(), "ELAN_HOME".to_string()],
            result_digest: "blake3:3333333333333333333333333333333333333333333333333333333333333333".to_string(),
            diagnostic_digest: "blake3:4444444444444444444444444444444444444444444444444444444444444444".to_string(),
        });
        assert_eq!(golden.witness_digest, "blake3:5e8e01eca1a2620549b6af9e9345c15ffba6c960f587ac0b9ec929b6b0b07b62");
        assert_eq!(compute_formal_blake3(&vec![b'A'; 3000]), "blake3:7b3b0f7dbb4d47318d00886cdae41ed2886dcaed7b6840372f9e570939f151ec");
        assert_eq!(verify_oracle_witness(&golden, None), OracleWitnessStatus::Verified);
        let stale_exp = WitnessFreshnessExpectation {
            source_digest: Some("blake3:9999999999999999999999999999999999999999999999999999999999999999".to_string()),
            theorem_digest: None, toolchain_version: None,
        };
        assert_eq!(verify_oracle_witness(&golden, Some(&stale_exp)), OracleWitnessStatus::StaleWitness);
        let skipped = build_oracle_witness(OracleWitnessInput {
            runtime_id: golden.runtime_id.clone(), profile_id: golden.profile_id.clone(), status: OracleWitnessStatus::SkippedUnavailable,
            source_digest: golden.source_digest.clone(), theorem_digest: golden.theorem_digest.clone(),
            toolchain_version: golden.toolchain_version.clone(), argv: golden.argv.clone(),
            env_allowlist: golden.env_allowlist.clone(), result_digest: golden.result_digest.clone(),
            diagnostic_digest: golden.diagnostic_digest.clone(),
        });
        assert_eq!(verify_oracle_witness(&skipped, None), OracleWitnessStatus::SkippedUnavailable);
        let mut tampered = golden.clone();
        tampered.toolchain_version = "Lean (version 4.99.0)".to_string();
        assert_eq!(verify_oracle_witness(&tampered, None), OracleWitnessStatus::Refuted);
    }
}