use serde::Serialize;
use crate::metrics::FailureBreakdown;
use crate::report::serde_str;
use crate::{FailureCaps, Promotion, Validity, Verdict};
#[derive(Debug, Serialize)]
pub struct TimeSensitiveReport {
pub schema_version: u32,
pub verdict: Verdict,
pub validity: Validity,
pub promotion: Promotion,
pub method: &'static str,
pub policy_kind: &'static str,
pub p0: f64,
pub p1: f64,
pub alpha: f64,
pub reward_kind: &'static str,
pub reward_parameters: serde_json::Value,
pub trial_count: u64,
pub decisive_count: u64,
pub draw_count: u64,
pub log_wealth: f64,
pub wealth_threshold: f64,
pub rejection_time: Option<u64>,
pub reward_at_rejection: Option<f64>,
pub planned_expected_reward_under_p1: f64,
pub action_grid_size: usize,
pub wealth_grid_size: usize,
pub numerical_tolerance: f64,
pub timeouts: u64,
pub crashes: u64,
pub invalid: u64,
pub failure_breakdown: FailureBreakdown,
pub reason: String,
pub notes: Vec<String>,
}
pub fn apply_failure_caps(report: &mut TimeSensitiveReport, caps: &FailureCaps) {
let (validity, reason) = caps.check(report.timeouts, report.crashes, report.invalid);
report.validity = validity;
if validity == Validity::Invalid {
report.verdict = Verdict::Inconclusive;
if let Some(reason) = reason {
report.reason = format!("INVALID: {reason}. Strength not evaluated.");
}
}
report.promotion = Promotion::decide(report.validity, report.verdict);
}
impl TimeSensitiveReport {
pub fn to_json_pretty(&self) -> String {
serde_json::to_string_pretty(self).expect(
"TimeSensitiveReport contains only finite fields and strings; serialization cannot fail",
)
}
pub fn to_markdown(&self) -> String {
let mut notes = String::new();
for n in &self.notes {
notes.push_str(&format!("- {n}\n"));
}
format!(
"# Veridict Time-Sensitive Report\n\n\
Verdict: {verdict} (validity: {validity}, promotion: {promotion})\n\n\
{reason}\n\n\
Method: {method} (policy: {policy_kind})\n\
p0={p0}, p1={p1}, alpha={alpha}\n\
Reward: {reward_kind} {reward_parameters}\n\n\
Trials: {trial_count} (decisive: {decisive_count}, draws: {draw_count})\n\
log_wealth={log_wealth:.4}, wealth_threshold={wealth_threshold:.4}\n\
rejection_time={rejection_time:?}, reward_at_rejection={reward_at_rejection:?}\n\
planned_expected_reward_under_p1={planned_expected_reward_under_p1:.6}\n\n\
Grid: action_grid_size={action_grid_size}, wealth_grid_size={wealth_grid_size}, \
numerical_tolerance={numerical_tolerance:.3e}\n\n\
Status counts: timeout={timeouts}, crash={crashes}, invalid={invalid}\n\n\
Notes:\n{notes}",
verdict = serde_str(&self.verdict),
validity = serde_str(&self.validity),
promotion = serde_str(&self.promotion),
reason = self.reason,
method = self.method,
policy_kind = self.policy_kind,
p0 = self.p0,
p1 = self.p1,
alpha = self.alpha,
reward_kind = self.reward_kind,
reward_parameters = self.reward_parameters,
trial_count = self.trial_count,
decisive_count = self.decisive_count,
draw_count = self.draw_count,
log_wealth = self.log_wealth,
wealth_threshold = self.wealth_threshold,
rejection_time = self.rejection_time,
reward_at_rejection = self.reward_at_rejection,
planned_expected_reward_under_p1 = self.planned_expected_reward_under_p1,
action_grid_size = self.action_grid_size,
wealth_grid_size = self.wealth_grid_size,
numerical_tolerance = self.numerical_tolerance,
timeouts = self.timeouts,
crashes = self.crashes,
invalid = self.invalid,
notes = notes,
)
}
}