use super::types::AdmissionDecision;
#[derive(Clone, Debug, PartialEq)]
pub struct TrustEnvelopeInput {
pub plan_summary: String,
pub decision: AdmissionDecision,
pub response_tokens: u32,
pub est_net_vs_manual: i32,
pub schema_tokens: u32,
pub invoke_tokens: u32,
pub predicted_tokens: u32,
pub predict_error_pct: f32,
pub session_tokens_served: i64,
pub calibration: &'static str,
pub ledger_line: Option<String>,
}
fn decision_label(decision: AdmissionDecision) -> &'static str {
match decision {
AdmissionDecision::Serve => "serve",
AdmissionDecision::Degrade => "degrade",
AdmissionDecision::Bypass => "bypass",
AdmissionDecision::CacheHit => "cache_hit",
AdmissionDecision::Reject => "reject",
}
}
pub fn format_trust_envelope(input: &TrustEnvelopeInput) -> String {
format_trust_envelope_inner(input, !stel_full_envelope_enabled())
}
fn stel_full_envelope_enabled() -> bool {
matches!(
std::env::var("SYMFORGE_STEL_FULL").ok().as_deref(),
Some("1") | Some("true") | Some("TRUE")
)
}
fn format_trust_envelope_inner(input: &TrustEnvelopeInput, compact: bool) -> String {
if compact {
return format!(
"── stel · {plan} · {decision} · ~{served} tok served (est.) ──",
plan = input.plan_summary,
decision = decision_label(input.decision),
served = input.response_tokens,
);
}
let est_net = input.est_net_vs_manual;
let net_label = if input.decision == AdmissionDecision::Reject {
"n/a (rejected)".to_string()
} else if est_net >= 0 {
format!("est. {est_net} fewer")
} else {
format!("est. {} more", est_net.abs())
};
format!(
"── stel ──\n\
plan: {plan}\n\
decision: {decision}\n\
tokens: ~{served} served (est. chars/4) · {net_label} vs manual (heuristic) · schema {schema} · invoke {invoke}\n\
predicted: ~{predicted} (heuristic) · error: {error:.1}%\n\
session_tokens_served: {session}\n\
calibration: {calibration}{ledger}\n\
──",
plan = input.plan_summary,
decision = decision_label(input.decision),
served = input.response_tokens,
net_label = net_label,
schema = input.schema_tokens,
invoke = input.invoke_tokens,
predicted = input.predicted_tokens,
error = input.predict_error_pct,
session = input.session_tokens_served,
calibration = input.calibration,
ledger = input
.ledger_line
.as_ref()
.map(|line| format!("\n{line}"))
.unwrap_or_default(),
)
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Mutex;
static ENV_LOCK: Mutex<()> = Mutex::new(());
struct StelFullEnvGuard {
previous: Option<std::ffi::OsString>,
}
impl StelFullEnvGuard {
#[allow(unsafe_code)] fn set(value: &str) -> Self {
let previous = std::env::var_os("SYMFORGE_STEL_FULL");
unsafe { std::env::set_var("SYMFORGE_STEL_FULL", value) };
Self { previous }
}
#[allow(unsafe_code)] fn unset() -> Self {
let previous = std::env::var_os("SYMFORGE_STEL_FULL");
unsafe { std::env::remove_var("SYMFORGE_STEL_FULL") };
Self { previous }
}
}
impl Drop for StelFullEnvGuard {
#[allow(unsafe_code)] fn drop(&mut self) {
match &self.previous {
Some(previous) => unsafe { std::env::set_var("SYMFORGE_STEL_FULL", previous) },
None => unsafe { std::env::remove_var("SYMFORGE_STEL_FULL") },
}
}
}
fn sample_input() -> TrustEnvelopeInput {
TrustEnvelopeInput {
plan_summary: "trace → find_references (exact)".to_string(),
decision: AdmissionDecision::Serve,
response_tokens: 420,
est_net_vs_manual: 380,
schema_tokens: 45,
invoke_tokens: 80,
predicted_tokens: 400,
predict_error_pct: 5.0,
session_tokens_served: 1240,
calibration: "deferred",
ledger_line: Some("ledger: {}".to_string()),
}
}
#[test]
fn envelope_matches_schema_example_shape() {
let text = format_trust_envelope_inner(
&TrustEnvelopeInput {
plan_summary: "trace → find_references (exact)".to_string(),
decision: AdmissionDecision::Serve,
response_tokens: 420,
est_net_vs_manual: 380,
schema_tokens: 45,
invoke_tokens: 80,
predicted_tokens: 400,
predict_error_pct: 5.0,
session_tokens_served: 1240,
calibration: "ok",
ledger_line: None,
},
false,
);
assert!(text.starts_with("── stel ──\n"));
assert!(text.contains("plan: trace → find_references (exact)"));
assert!(text.contains("decision: serve"));
assert!(text.contains("~420 served (est. chars/4)"));
assert!(text.contains("est. 380 fewer vs manual (heuristic)"));
assert!(text.contains("session_tokens_served: 1240"));
assert!(!text.contains("session_net_vs_manual"));
assert!(text.ends_with("──"));
}
#[test]
fn reject_decision_never_prints_a_positive_saving() {
let text = format_trust_envelope_inner(
&TrustEnvelopeInput {
plan_summary: "trace → find_references (exact)".to_string(),
decision: AdmissionDecision::Reject,
response_tokens: 100,
est_net_vs_manual: 213,
schema_tokens: 45,
invoke_tokens: 80,
predicted_tokens: 400,
predict_error_pct: 0.0,
session_tokens_served: 213,
calibration: "deferred",
ledger_line: None,
},
false,
);
assert!(text.contains("decision: reject"));
assert!(text.contains("n/a (rejected) vs manual"));
assert!(!text.contains("fewer vs manual"));
assert!(!text.contains("213 saved"));
}
#[test]
fn compact_envelope_inner_is_one_honest_line() {
let input = TrustEnvelopeInput {
plan_summary: "find → search_text".to_string(),
decision: AdmissionDecision::Serve,
response_tokens: 1234,
est_net_vs_manual: 50,
schema_tokens: 10,
invoke_tokens: 20,
predicted_tokens: 800,
predict_error_pct: 12.0,
session_tokens_served: 5000,
calibration: "deferred",
ledger_line: Some("ledger: {}".to_string()),
};
let compact = format_trust_envelope_inner(&input, true);
assert_eq!(
compact.lines().count(),
1,
"compact envelope is one line: {compact}"
);
assert!(compact.contains("serve"), "keeps the decision: {compact}");
assert!(
compact.contains("~1234 tok served (est.)"),
"keeps est. served tokens: {compact}"
);
assert!(
!compact.contains("session_tokens_served") && !compact.contains("predicted:"),
"drops the per-call detail: {compact}"
);
let full = format_trust_envelope_inner(&input, false);
assert!(
full.lines().count() > 1 && full.contains("session_tokens_served:"),
"full form stays the multi-line block: {full}"
);
}
#[test]
fn default_render_is_the_compact_one_liner() {
let input = TrustEnvelopeInput {
plan_summary: "trace → find_references (exact)".to_string(),
decision: AdmissionDecision::Serve,
response_tokens: 420,
est_net_vs_manual: 380,
schema_tokens: 45,
invoke_tokens: 80,
predicted_tokens: 400,
predict_error_pct: 5.0,
session_tokens_served: 1240,
calibration: "deferred",
ledger_line: Some("ledger: {}".to_string()),
};
let default_render = format_trust_envelope_inner(&input, true);
assert_eq!(
default_render.lines().count(),
1,
"default render is a single line: {default_render}"
);
assert!(
default_render.contains("serve"),
"default render keeps the decision label: {default_render}"
);
assert!(
default_render.contains("(est.)"),
"default render keeps the est. served-token label: {default_render}"
);
for forbidden in [
"session_tokens_served",
"predicted:",
" saved ",
"fewer vs manual",
"vs manual",
] {
assert!(
!default_render.contains(forbidden),
"default render must drop `{forbidden}`: {default_render}"
);
}
}
#[test]
fn public_entry_default_is_compact_full_is_opt_in() {
let _lock = ENV_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
let input = sample_input();
{
let _unset = StelFullEnvGuard::unset();
let default_render = format_trust_envelope(&input);
assert_eq!(
default_render.lines().count(),
1,
"unset SYMFORGE_STEL_FULL must yield the compact one-liner: {default_render}"
);
assert!(
default_render.contains("(est.)"),
"compact default keeps the est. served-token label: {default_render}"
);
assert!(
!default_render.contains("session_tokens_served:"),
"compact default drops the gross session counter: {default_render}"
);
}
{
let _full = StelFullEnvGuard::set("1");
let full_render = format_trust_envelope(&input);
assert!(
full_render.lines().count() > 1,
"SYMFORGE_STEL_FULL=1 must restore the multi-line block: {full_render}"
);
assert!(
full_render.starts_with("── stel ──\n"),
"full render is the `── stel ──` block: {full_render}"
);
assert!(
full_render.contains("session_tokens_served:"),
"full render carries the per-call economics: {full_render}"
);
}
}
#[test]
fn public_entry_compact_flag_is_a_noop() {
let _lock = ENV_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
let _unset_full = StelFullEnvGuard::unset();
let compact_guard = CompactEnvGuard::set("1");
let render = format_trust_envelope(&sample_input());
drop(compact_guard);
assert_eq!(
render.lines().count(),
1,
"SYMFORGE_STEL_COMPACT alone is a no-op; compact stays the default: {render}"
);
}
struct CompactEnvGuard {
previous: Option<std::ffi::OsString>,
}
impl CompactEnvGuard {
#[allow(unsafe_code)] fn set(value: &str) -> Self {
let previous = std::env::var_os("SYMFORGE_STEL_COMPACT");
unsafe { std::env::set_var("SYMFORGE_STEL_COMPACT", value) };
Self { previous }
}
}
impl Drop for CompactEnvGuard {
#[allow(unsafe_code)] fn drop(&mut self) {
match &self.previous {
Some(previous) => unsafe { std::env::set_var("SYMFORGE_STEL_COMPACT", previous) },
None => unsafe { std::env::remove_var("SYMFORGE_STEL_COMPACT") },
}
}
}
}