use crate::protocol::format::{competent_manual_baseline_chars, estimate_tokens_from_chars};
use crate::protocol::session::SessionContext;
use super::ledger_store::TunedEstimateConstants;
use super::types::{
AdmissionDecision, GoldenRouteRow, IndexRef, RouteConfidence, StelBypassBody, StelCacheBody,
StelDecision, StelEstimate, StelPlan, StelPlanStep, StelRequest,
};
pub use crate::stel_core::consts::{
COMPACT_INVOKE_TOKENS, COMPACT_SCHEMA_TOKENS, STATIC_MANUAL_FLOOR, STATIC_RESPONSE_FLOOR,
};
pub const SERVE_MARGIN_TOKENS: i32 = 50;
pub const DEGRADE_MARGIN_LOW_TOKENS: i32 = SERVE_MARGIN_TOKENS;
pub const DEGRADE_DEFAULT_MAX_TOKENS: u32 = 400;
const GROUNDED_RESPONSE_FRACTION_NUM: u64 = 3;
const GROUNDED_RESPONSE_FRACTION_DEN: u64 = 5;
const EDIT_RESPONSE_FOOTER_TOKENS: u64 = 60;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct EconomicsBreakdown {
pub predicted_response_tokens: u32,
pub raw_predicted_response_tokens: u32,
pub predicted_manual_tokens: u32,
pub predicted_schema_tokens: u32,
pub predicted_invoke_tokens: u32,
pub predicted_symforge_tokens: u32,
pub predicted_net_vs_manual: i32,
}
pub fn evaluate_plan(request: &StelRequest, plan: &StelPlan) -> StelDecision {
evaluate_plan_with_session(request, plan, None)
}
pub fn evaluate_plan_with_session(
request: &StelRequest,
plan: &StelPlan,
session: Option<&SessionContext>,
) -> StelDecision {
evaluate_plan_tuned(request, plan, session, None)
}
pub fn evaluate_plan_tuned(
request: &StelRequest,
plan: &StelPlan,
session: Option<&SessionContext>,
tuned: Option<&TunedEstimateConstants>,
) -> StelDecision {
if let Some(bypass) = detect_pff_bypass(request) {
return decision_from_pff_bypass(plan, request, bypass);
}
if let Some(session) = session
&& let Some(cache) = detect_session_cache_hit(plan, session)
{
return decision_from_cache_hit(plan, request, cache);
}
let economics = estimate_economics_tuned(plan, tuned);
let net = economics.predicted_net_vs_manual;
if net <= 0 {
let bypass = economics_bypass_body(plan, &economics);
return StelDecision {
plan_id: plan.plan_id.clone(),
decision: AdmissionDecision::Bypass,
decision_reason: format!(
"predicted_net={net} <= 0; economics bypass via host_read `{}`",
bypass.path
),
effective_max_tokens: request.max_tokens,
degrade_flags: vec![],
steps: None,
bypass: Some(bypass),
cache: None,
};
}
let mandatory_degrade =
plan.confidence == RouteConfidence::Fallback && net < SERVE_MARGIN_TOKENS;
let economics_degrade = net <= DEGRADE_MARGIN_LOW_TOKENS;
if mandatory_degrade || economics_degrade {
let mut degrade_flags = Vec::new();
if mandatory_degrade {
degrade_flags.push("fallback_mandatory".to_string());
}
if plan
.steps
.iter()
.any(|step| step.tool == "get_file_context")
{
degrade_flags.push("outline_only".to_string());
} else {
degrade_flags.push("max_tokens_cap".to_string());
}
degrade_flags.sort();
degrade_flags.dedup();
let effective_max_tokens = request
.max_tokens
.or(Some(DEGRADE_DEFAULT_MAX_TOKENS))
.map(|cap| cap.min(DEGRADE_DEFAULT_MAX_TOKENS));
let reason = if mandatory_degrade {
format!(
"predicted_net={net} < margin={}; fallback confidence requires degrade",
SERVE_MARGIN_TOKENS
)
} else {
format!(
"predicted_net={net} <= margin_low={}",
DEGRADE_MARGIN_LOW_TOKENS
)
};
return StelDecision {
plan_id: plan.plan_id.clone(),
decision: AdmissionDecision::Degrade,
decision_reason: reason,
effective_max_tokens,
degrade_flags,
steps: Some(plan.steps.clone()),
bypass: None,
cache: None,
};
}
StelDecision {
plan_id: plan.plan_id.clone(),
decision: AdmissionDecision::Serve,
decision_reason: format!("predicted_net={net} > margin={}", SERVE_MARGIN_TOKENS),
effective_max_tokens: request.max_tokens,
degrade_flags: vec![],
steps: Some(plan.steps.clone()),
bypass: None,
cache: None,
}
}
fn decision_from_pff_bypass(
plan: &StelPlan,
request: &StelRequest,
bypass: StelBypassBody,
) -> StelDecision {
let economics = economics_for_bypass(&bypass);
StelDecision {
plan_id: plan.plan_id.clone(),
decision: AdmissionDecision::Bypass,
decision_reason: format!(
"{}; predicted_net={}",
bypass.reason, economics.predicted_net_vs_manual
),
effective_max_tokens: request.max_tokens,
degrade_flags: vec![],
steps: None,
bypass: Some(bypass),
cache: None,
}
}
fn decision_from_cache_hit(
plan: &StelPlan,
request: &StelRequest,
cache: StelCacheBody,
) -> StelDecision {
StelDecision {
plan_id: plan.plan_id.clone(),
decision: AdmissionDecision::CacheHit,
decision_reason: format!(
"session cache hit for {} `{}` (prior_tokens={})",
cache.kind, cache.path, cache.prior_tokens
),
effective_max_tokens: request.max_tokens,
degrade_flags: vec![],
steps: None,
bypass: None,
cache: Some(cache),
}
}
fn detect_session_cache_hit(plan: &StelPlan, session: &SessionContext) -> Option<StelCacheBody> {
let step = plan.steps.first()?;
session
.try_cache_hit_from_stel_step(&step.tool, &step.args)
.map(|meta| StelCacheBody {
kind: meta.kind.to_string(),
path: meta.path,
name: meta.name,
prior_tokens: meta.prior_tokens,
session_age_secs: meta.session_age_secs,
})
}
fn economics_bypass_body(plan: &StelPlan, economics: &EconomicsBreakdown) -> StelBypassBody {
let path = plan_primary_path(plan).unwrap_or_else(|| "unknown".to_string());
StelBypassBody {
action: "host_read".to_string(),
path: path.clone(),
start_line: 1,
end_line: Some(80),
predicted_manual_tokens: economics.predicted_manual_tokens,
predicted_symforge_tokens: economics.predicted_symforge_tokens,
reason: format!(
"predicted_net={} <= 0; host_read `{path}` cheaper than serve",
economics.predicted_net_vs_manual
),
}
}
fn plan_primary_path(plan: &StelPlan) -> Option<String> {
plan.steps.first().and_then(primary_path_from_step)
}
fn primary_path_from_step(step: &StelPlanStep) -> Option<String> {
step.args
.get("path")
.and_then(|value| value.as_str())
.map(str::trim)
.filter(|path| !path.is_empty())
.map(str::to_string)
.or_else(|| {
step.args
.get("name")
.and_then(|value| value.as_str())
.map(str::trim)
.filter(|name| !name.is_empty())
.map(str::to_string)
})
}
pub fn evaluate_edit_plan(plan: &StelPlan) -> StelDecision {
let economics = estimate_economics(plan);
let net = economics.predicted_net_vs_manual;
StelDecision {
plan_id: plan.plan_id.clone(),
decision: AdmissionDecision::Serve,
decision_reason: format!("predicted_net={net} (est.); structural edit always serves"),
effective_max_tokens: None,
degrade_flags: vec![],
steps: Some(plan.steps.clone()),
bypass: None,
cache: None,
}
}
pub fn build_estimate(
request: &StelRequest,
plan: &StelPlan,
decision: &StelDecision,
) -> StelEstimate {
let economics = if decision.decision == AdmissionDecision::Bypass {
decision
.bypass
.as_ref()
.map(economics_for_bypass)
.unwrap_or_else(|| estimate_economics(plan))
} else {
estimate_economics(plan)
};
let recommended = decision.decision == AdmissionDecision::Serve
&& economics.predicted_net_vs_manual > SERVE_MARGIN_TOKENS;
let _ = request;
StelEstimate {
plan_id: plan.plan_id.clone(),
decision: decision.decision,
predicted_response_tokens: economics.predicted_response_tokens,
predicted_manual_tokens: economics.predicted_manual_tokens,
predicted_schema_tokens: economics.predicted_schema_tokens,
predicted_invoke_tokens: economics.predicted_invoke_tokens,
predicted_net_vs_manual: economics.predicted_net_vs_manual,
recommended,
}
}
pub fn estimate_economics(plan: &StelPlan) -> EconomicsBreakdown {
estimate_economics_tuned(plan, None)
}
pub fn active_tuning_in_force(
tuned: Option<TunedEstimateConstants>,
current_version: &str,
) -> Option<TunedEstimateConstants> {
tuned.filter(|c| c.estimator_version == current_version)
}
pub fn estimate_economics_tuned(
plan: &StelPlan,
tuned: Option<&TunedEstimateConstants>,
) -> EconomicsBreakdown {
let (predicted_response_raw, predicted_manual_tokens) = plan
.steps
.iter()
.map(grounded_step_tokens)
.fold((0u32, 0u32), |(resp, manual), (step_resp, step_manual)| {
(
resp.saturating_add(step_resp),
manual.saturating_add(step_manual),
)
});
let predicted_response_tokens = match tuned {
Some(c) => crate::stel_core::calibration::apply_factor(
predicted_response_raw,
c.response_correction_factor,
),
None => predicted_response_raw,
};
let schema_tokens = COMPACT_SCHEMA_TOKENS;
let invoke_tokens = COMPACT_INVOKE_TOKENS;
let predicted_symforge_tokens = predicted_response_tokens
.saturating_add(schema_tokens)
.saturating_add(invoke_tokens);
let predicted_net_vs_manual = predicted_manual_tokens as i32 - predicted_symforge_tokens as i32;
EconomicsBreakdown {
predicted_response_tokens,
raw_predicted_response_tokens: predicted_response_raw,
predicted_manual_tokens,
predicted_schema_tokens: schema_tokens,
predicted_invoke_tokens: invoke_tokens,
predicted_symforge_tokens,
predicted_net_vs_manual,
}
}
fn grounded_step_tokens(step: &StelPlanStep) -> (u32, u32) {
if step.index_refs.is_empty() {
return (step.est_response_tokens, step.est_manual_tokens);
}
let total_raw_chars: usize = step
.index_refs
.iter()
.map(|index_ref| index_ref.raw_chars as usize)
.sum();
if matches!(
step.tool.as_str(),
"replace_symbol_body" | "insert_symbol" | "edit_within_symbol"
) {
return grounded_edit_tokens(step, total_raw_chars);
}
grounded_tokens_from_raw_chars(total_raw_chars)
}
fn grounded_edit_tokens(step: &StelPlanStep, body_chars: usize) -> (u32, u32) {
let manual_chars = competent_manual_baseline_chars(body_chars);
let manual_tokens = estimate_tokens_from_chars(manual_chars);
let is_preview = step
.args
.get("dry_run")
.and_then(serde_json::Value::as_bool)
.unwrap_or(true);
let response_tokens = if is_preview {
estimate_tokens_from_chars(body_chars).saturating_add(EDIT_RESPONSE_FOOTER_TOKENS)
} else {
EDIT_RESPONSE_FOOTER_TOKENS
};
(clamp_u32(response_tokens), clamp_u32(manual_tokens))
}
fn grounded_tokens_from_raw_chars(raw_chars: usize) -> (u32, u32) {
let manual_chars = competent_manual_baseline_chars(raw_chars);
let manual_tokens = estimate_tokens_from_chars(manual_chars);
let response_tokens = manual_tokens.saturating_mul(GROUNDED_RESPONSE_FRACTION_NUM)
/ GROUNDED_RESPONSE_FRACTION_DEN;
(clamp_u32(response_tokens), clamp_u32(manual_tokens))
}
fn clamp_u32(value: u64) -> u32 {
value.min(u32::MAX as u64) as u32
}
pub fn index_ref_for_target(path: impl Into<String>, raw_chars: u64) -> IndexRef {
IndexRef {
path: path.into(),
raw_chars,
}
}
pub fn economics_for_bypass(bypass: &StelBypassBody) -> EconomicsBreakdown {
let predicted_symforge_tokens = bypass
.predicted_symforge_tokens
.saturating_add(COMPACT_SCHEMA_TOKENS)
.saturating_add(COMPACT_INVOKE_TOKENS);
let predicted_net_vs_manual =
bypass.predicted_manual_tokens as i32 - predicted_symforge_tokens as i32;
EconomicsBreakdown {
predicted_response_tokens: 0,
raw_predicted_response_tokens: 0,
predicted_manual_tokens: bypass.predicted_manual_tokens,
predicted_schema_tokens: COMPACT_SCHEMA_TOKENS,
predicted_invoke_tokens: COMPACT_INVOKE_TOKENS,
predicted_symforge_tokens,
predicted_net_vs_manual,
}
}
pub fn detect_pff_bypass(request: &StelRequest) -> Option<StelBypassBody> {
let query = request.query.trim();
let lower = query.to_ascii_lowercase();
if !is_pff_query(&lower) {
return None;
}
let path = extract_pff_path(query, &lower)?;
Some(StelBypassBody {
action: "host_read".to_string(),
path: path.clone(),
start_line: 1,
end_line: None,
predicted_manual_tokens: 320,
predicted_symforge_tokens: COMPACT_SCHEMA_TOKENS + COMPACT_INVOKE_TOKENS + 256,
reason: format!("policy=P-FF whole-file review; host_read `{path}`"),
})
}
fn is_pff_query(lower: &str) -> bool {
const PHRASES: &[&str] = &[
"entire ",
"whole ",
"full file",
"complete ",
"line by line",
"audit full ",
"review entire ",
"read complete ",
];
PHRASES.iter().any(|phrase| lower.contains(phrase))
}
fn extract_pff_path(query: &str, lower: &str) -> Option<String> {
for token in query.split_whitespace().rev() {
let cleaned = token.trim_matches(|c: char| !c.is_alphanumeric() && c != '.' && c != '/');
if cleaned.contains('.') && !cleaned.eq_ignore_ascii_case("line") {
return Some(cleaned.to_string());
}
}
for token in lower.split_whitespace() {
if token.contains('.') {
return Some(token.to_string());
}
}
None
}
pub fn decision_matches_golden(
row: &GoldenRouteRow,
plan: &StelPlan,
request: &StelRequest,
) -> bool {
let decision = evaluate_plan(request, plan);
decision.decision == row.expected_decision
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::Path;
use crate::stel::golden_replay::{GOLDEN_ROUTES_FIXTURE, load_golden_rows};
use crate::stel::planner::build_plan;
use crate::stel::types::{IntentBucket, RouteConfidence, StelPlan, StelPlanStep};
fn row_by_id<'a>(rows: &'a [GoldenRouteRow], id: &str) -> &'a GoldenRouteRow {
rows.iter()
.find(|row| row.id == id)
.unwrap_or_else(|| panic!("missing golden row {id}"))
}
fn request_for_row(row: &GoldenRouteRow) -> StelRequest {
let mut request = row.to_request();
request.intent = row.intent;
request
}
fn low_net_plan() -> StelPlan {
StelPlan {
plan_id: "low-net".to_string(),
intent: IntentBucket::Read,
confidence: RouteConfidence::Inferred,
confidence_rationale: "test".to_string(),
steps: vec![StelPlanStep {
order: 1,
tool: "get_file_context".to_string(),
args: serde_json::json!({ "path": "src/lib.rs" }),
est_response_tokens: 900,
est_manual_tokens: 100,
index_refs: vec![],
}],
suggested_followup: None,
}
}
#[test]
fn serve_rows_classify_as_serve() {
let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(GOLDEN_ROUTES_FIXTURE);
let rows = load_golden_rows(&path).expect("golden fixture");
for id in [
"cfg-if/t1_search",
"cfg-if/t4_refs",
"records/t4_refs",
"compression/t5_dependents",
] {
let row = row_by_id(&rows, id);
let request = request_for_row(row);
let plan = build_plan(&request);
let decision = evaluate_plan(&request, &plan);
assert_eq!(
decision.decision,
AdmissionDecision::Serve,
"{id}: {:?}",
decision.decision_reason
);
assert!(row.eligible_h6.unwrap_or(false));
let economics = estimate_economics(&plan);
assert!(
economics.predicted_net_vs_manual > SERVE_MARGIN_TOKENS,
"{id} net {}",
economics.predicted_net_vs_manual
);
}
}
#[test]
fn pff_rows_classify_as_bypass() {
let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(GOLDEN_ROUTES_FIXTURE);
let rows = load_golden_rows(&path).expect("golden fixture");
for id in [
"cfg-if/pff_whole_lib",
"records/pff_whole_module",
"is-plain/pff_whole_index",
"compression/pff_whole_service",
] {
let row = row_by_id(&rows, id);
let request = request_for_row(row);
let plan = build_plan(&request);
let decision = evaluate_plan(&request, &plan);
assert_eq!(decision.decision, AdmissionDecision::Bypass, "{id}");
assert!(decision.bypass.is_some(), "{id} bypass body");
let bypass = decision.bypass.as_ref().expect("bypass body");
assert_eq!(
bypass.end_line, None,
"{id} P-FF bypass must request whole-file host read"
);
assert_eq!(row.eligible_h6, Some(false));
let estimate = build_estimate(&request, &plan, &decision);
assert!(!estimate.recommended, "{id} should not recommend serve");
}
}
#[test]
fn negative_net_non_pff_bypass_has_host_read_body() {
let plan = low_net_plan();
let request = StelRequest::default();
let decision = evaluate_plan(&request, &plan);
assert_eq!(decision.decision, AdmissionDecision::Bypass);
let bypass = decision.bypass.as_ref().expect("economics bypass body");
assert_eq!(bypass.path, "src/lib.rs");
assert!(decision.decision_reason.contains("predicted_net="));
}
#[test]
fn marginal_net_degrades_with_outline_only_flag() {
let plan = StelPlan {
plan_id: "degrade".to_string(),
intent: IntentBucket::Read,
confidence: RouteConfidence::Inferred,
confidence_rationale: "test".to_string(),
steps: vec![StelPlanStep {
order: 1,
tool: "get_file_context".to_string(),
args: serde_json::json!({ "path": "src/lib.rs" }),
est_response_tokens: 400,
est_manual_tokens: 530,
index_refs: vec![],
}],
suggested_followup: None,
};
let request = StelRequest::default();
let decision = evaluate_plan(&request, &plan);
assert_eq!(decision.decision, AdmissionDecision::Degrade);
assert!(decision.degrade_flags.contains(&"outline_only".to_string()));
assert!(decision.effective_max_tokens.is_some());
}
#[test]
fn fallback_confidence_forces_degrade_below_margin_high() {
let plan = StelPlan {
plan_id: "fallback".to_string(),
intent: IntentBucket::Read,
confidence: RouteConfidence::Fallback,
confidence_rationale: "test".to_string(),
steps: vec![StelPlanStep {
order: 1,
tool: "get_file_content".to_string(),
args: serde_json::json!({ "path": "src/lib.rs" }),
est_response_tokens: 400,
est_manual_tokens: 530,
index_refs: vec![],
}],
suggested_followup: None,
};
let request = StelRequest::default();
let decision = evaluate_plan(&request, &plan);
assert_eq!(decision.decision, AdmissionDecision::Degrade);
assert!(
decision
.degrade_flags
.contains(&"fallback_mandatory".to_string())
);
}
#[test]
fn session_prefetch_does_not_stel_cache_hit_get_symbol() {
let session = SessionContext::new();
session.record_symbol_fetch(
"src/lib.rs",
"cfg_if",
crate::protocol::session::hash_symbol_params(None, None, None, 0, "unavailable", 0, 0),
128,
"deadbeefcafe",
);
let plan = StelPlan {
plan_id: "cache".to_string(),
intent: IntentBucket::Read,
confidence: RouteConfidence::Exact,
confidence_rationale: "test".to_string(),
steps: vec![StelPlanStep {
order: 1,
tool: "get_symbol".to_string(),
args: serde_json::json!({ "path": "src/lib.rs", "name": "cfg_if" }),
est_response_tokens: 400,
est_manual_tokens: 800,
index_refs: vec![],
}],
suggested_followup: None,
};
let request = StelRequest::default();
let decision = evaluate_plan_with_session(&request, &plan, Some(&session));
assert_ne!(
decision.decision,
AdmissionDecision::CacheHit,
"plan layer has no generation identity; the primitive must run"
);
assert!(decision.cache.is_none());
}
#[test]
fn eligible_h6_serve_rows_remain_eligible() {
let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(GOLDEN_ROUTES_FIXTURE);
let rows = load_golden_rows(&path).expect("golden fixture");
let eligible: Vec<_> = rows
.iter()
.filter(|row| {
row.eligible_h6 == Some(true) && row.expected_decision == AdmissionDecision::Serve
})
.collect();
assert!(eligible.len() >= 20);
for row in eligible.iter().take(6) {
let request = request_for_row(row);
let plan = build_plan(&request);
assert!(
decision_matches_golden(row, &plan, &request),
"eligible serve row {} decision mismatch",
row.id
);
}
}
#[test]
fn preview_estimate_carries_schema_and_invoke_costs() {
let request = StelRequest {
query: "who references cfg_if".to_string(),
..Default::default()
};
let plan = build_plan(&request);
let decision = evaluate_plan(&request, &plan);
let estimate = build_estimate(&request, &plan, &decision);
assert_eq!(estimate.predicted_schema_tokens, COMPACT_SCHEMA_TOKENS);
assert_eq!(estimate.predicted_invoke_tokens, COMPACT_INVOKE_TOKENS);
assert_eq!(estimate.decision, AdmissionDecision::Serve);
assert!(estimate.recommended);
}
#[test]
fn fallback_confidence_still_serves_when_net_positive() {
let plan = StelPlan {
plan_id: "test".to_string(),
intent: IntentBucket::Read,
confidence: RouteConfidence::Fallback,
confidence_rationale: "test".to_string(),
steps: vec![StelPlanStep {
order: 1,
tool: "get_file_context".to_string(),
args: serde_json::json!({}),
est_response_tokens: 400,
est_manual_tokens: 800,
index_refs: vec![],
}],
suggested_followup: None,
};
let request = StelRequest::default();
let decision = evaluate_plan(&request, &plan);
assert_eq!(decision.decision, AdmissionDecision::Serve);
}
fn grounded_read_plan(raw_chars: u64, confidence: RouteConfidence) -> StelPlan {
StelPlan {
plan_id: format!("grounded-{raw_chars}"),
intent: IntentBucket::Read,
confidence,
confidence_rationale: "test".to_string(),
steps: vec![StelPlanStep {
order: 1,
tool: "get_file_context".to_string(),
args: serde_json::json!({ "path": "src/lib.rs" }),
est_response_tokens: 400,
est_manual_tokens: 800,
index_refs: vec![IndexRef {
path: "src/lib.rs".to_string(),
raw_chars,
}],
}],
suggested_followup: None,
}
}
#[test]
fn grounded_predictions_vary_with_real_input_size() {
let small = estimate_economics(&grounded_read_plan(600, RouteConfidence::Inferred));
let large = estimate_economics(&grounded_read_plan(40_000, RouteConfidence::Inferred));
assert_ne!(
small.predicted_manual_tokens, large.predicted_manual_tokens,
"manual baseline must vary with real size"
);
assert_ne!(
small.predicted_net_vs_manual, large.predicted_net_vs_manual,
"predicted net must vary with real size"
);
assert!(
large.predicted_manual_tokens > small.predicted_manual_tokens,
"bigger file ⇒ bigger manual baseline (small={} large={})",
small.predicted_manual_tokens,
large.predicted_manual_tokens
);
assert!(
large.predicted_net_vs_manual > small.predicted_net_vs_manual,
"bigger file ⇒ higher predicted net (small={} large={})",
small.predicted_net_vs_manual,
large.predicted_net_vs_manual
);
let plan_only = StelPlan {
steps: vec![StelPlanStep {
index_refs: vec![],
..grounded_read_plan(600, RouteConfidence::Inferred).steps[0].clone()
}],
..grounded_read_plan(600, RouteConfidence::Inferred)
};
let floor = estimate_economics(&plan_only);
assert_eq!(floor.predicted_response_tokens, 400);
assert_eq!(floor.predicted_manual_tokens, 800);
}
#[test]
fn grounded_small_request_reaches_economics_bypass() {
let tiny = grounded_read_plan(180, RouteConfidence::Inferred);
let economics = estimate_economics(&tiny);
assert!(
economics.predicted_net_vs_manual <= 0,
"tiny grounded request must predict non-positive net, got {}",
economics.predicted_net_vs_manual
);
let decision = evaluate_plan(&StelRequest::default(), &tiny);
assert_eq!(
decision.decision,
AdmissionDecision::Bypass,
"tiny grounded request must reach economics bypass: {}",
decision.decision_reason
);
assert!(
decision.bypass.is_some(),
"economics bypass must carry a host-read body"
);
}
fn grounded_edit_plan(body_chars: u64, dry_run: bool) -> StelPlan {
StelPlan {
plan_id: format!("edit-{body_chars}-{dry_run}"),
intent: IntentBucket::Edit,
confidence: RouteConfidence::Exact,
confidence_rationale: "test".to_string(),
steps: vec![StelPlanStep {
order: 1,
tool: "replace_symbol_body".to_string(),
args: serde_json::json!({
"path": "src/lib.rs",
"name": "foo",
"new_body": "x",
"dry_run": dry_run,
}),
est_response_tokens: 520,
est_manual_tokens: 900,
index_refs: vec![IndexRef {
path: "src/lib.rs".to_string(),
raw_chars: body_chars,
}],
}],
suggested_followup: None,
}
}
#[test]
fn grounded_edit_preview_response_scales_with_body_size() {
let small = estimate_economics(&grounded_edit_plan(400, true));
let large = estimate_economics(&grounded_edit_plan(40_000, true));
assert_ne!(
small.predicted_response_tokens, 520,
"grounded edit must override the flat 520 response floor"
);
assert_ne!(
small.predicted_response_tokens, large.predicted_response_tokens,
"edit response prediction must vary with new-body size"
);
assert!(
large.predicted_response_tokens > small.predicted_response_tokens,
"bigger edit body ⇒ more echoed response (small={} large={})",
small.predicted_response_tokens,
large.predicted_response_tokens
);
assert!(
large.predicted_manual_tokens > small.predicted_manual_tokens,
"bigger edit body ⇒ bigger manual baseline (small={} large={})",
small.predicted_manual_tokens,
large.predicted_manual_tokens
);
}
#[test]
fn grounded_edit_preview_predicts_more_response_than_apply() {
let preview = estimate_economics(&grounded_edit_plan(40_000, true));
let apply = estimate_economics(&grounded_edit_plan(40_000, false));
assert!(
preview.predicted_response_tokens > apply.predicted_response_tokens,
"preview (echoes body) must predict more response than apply (footer only): \
preview={} apply={}",
preview.predicted_response_tokens,
apply.predicted_response_tokens
);
let apply_small = estimate_economics(&grounded_edit_plan(400, false));
assert_eq!(
apply.predicted_response_tokens, apply_small.predicted_response_tokens,
"committed apply does not re-emit the body ⇒ response is body-size invariant"
);
assert_eq!(
preview.predicted_manual_tokens, apply.predicted_manual_tokens,
"manual baseline depends on the symbol span, not on preview-vs-apply"
);
}
#[test]
fn grounded_tiny_edit_still_serves_no_bypass() {
let decision = evaluate_edit_plan(&grounded_edit_plan(8, true));
assert_eq!(
decision.decision,
AdmissionDecision::Serve,
"tiny edit must still serve (no host-read substitute): {}",
decision.decision_reason
);
assert!(
decision.bypass.is_none(),
"edit decision must never carry a host-read bypass body"
);
}
#[test]
fn grounded_fallback_marginal_reaches_mandatory_degrade() {
let plan = grounded_read_plan(1600, RouteConfidence::Fallback);
let economics = estimate_economics(&plan);
assert!(
economics.predicted_net_vs_manual > 0
&& economics.predicted_net_vs_manual < SERVE_MARGIN_TOKENS,
"grounded net must be marginal (0 < net < {SERVE_MARGIN_TOKENS}), got {}",
economics.predicted_net_vs_manual
);
let decision = evaluate_plan(&StelRequest::default(), &plan);
assert_eq!(
decision.decision,
AdmissionDecision::Degrade,
"marginal fallback must degrade: {}",
decision.decision_reason
);
assert!(
decision
.degrade_flags
.contains(&"fallback_mandatory".to_string()),
"N-2: low-confidence fallback must carry the mandatory degrade guardrail: {:?}",
decision.degrade_flags
);
}
}