synth-optimizers 0.2.7.dev20260814__tar.gz → 0.2.9.dev20260814__tar.gz

{synth_optimizers-0.2.7.dev20260814 → synth_optimizers-0.2.9.dev20260814}/Cargo.lock

@@ -1306,7 +1306,7 @@ dependencies = [
 
 [[package]]
 name = "synth_gepa"
-version = "0.2.7"
+version = "0.2.9"
 dependencies = [
  "base64",
  "fs2",
@@ -1321,7 +1321,7 @@ dependencies = [
 
 [[package]]
 name = "synth_mapo"
-version = "0.2.7"
+version = "0.2.9"
 dependencies = [
  "serde",
  "serde_json",
@@ -1333,7 +1333,7 @@ dependencies = [
 
 [[package]]
 name = "synth_marl_promptopt"
-version = "0.2.7"
+version = "0.2.9"
 dependencies = [
  "clap",
  "serde",
@@ -1347,7 +1347,7 @@ dependencies = [
 
 [[package]]
 name = "synth_optimizer_platform"
-version = "0.2.7"
+version = "0.2.9"
 dependencies = [
  "fs2",
  "libc",
@@ -1364,7 +1364,7 @@ dependencies = [
 
 [[package]]
 name = "synth_optimizers_py"
-version = "0.2.7"
+version = "0.2.9"
 dependencies = [
  "pyo3",
  "serde_json",

{synth_optimizers-0.2.7.dev20260814 → synth_optimizers-0.2.9.dev20260814}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["rust/crates/synth_optimizer_platform", "rust/crates/synth_gepa", "ru
 resolver = "2"
 
 [workspace.package]
-version = "0.2.7"
+version = "0.2.9"
 edition = "2021"
 license = "Apache-2.0"
 authors = ["Synth Laboratories <josh@usesynth.ai>"]

{synth_optimizers-0.2.7.dev20260814 → synth_optimizers-0.2.9.dev20260814}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-optimizers
-Version: 0.2.7.dev20260814
+Version: 0.2.9.dev20260814
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: synth-containers==0.4.1.dev20260814
 Requires-Dist: websocket-client>=1.8.0

{synth_optimizers-0.2.7.dev20260814 → synth_optimizers-0.2.9.dev20260814}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-optimizers"
-version = "0.2.7.dev20260814"
+version = "0.2.9.dev20260814"
 description = "Public Synth optimizer tooling with a Rust GEPA core."
 authors = [{name = "Synth Laboratories", email = "josh@usesynth.ai"}]
 readme = "README.md"

{synth_optimizers-0.2.7.dev20260814 → synth_optimizers-0.2.9.dev20260814}/rust/crates/synth_gepa/src/codex_app_server.rs

@@ -10,10 +10,10 @@ use reqwest::blocking::Client;
 use serde_json::{json, Map, Value};
 use synth_optimizer_platform::{
     jesterky_workspace_read_model, looks_like_jesterky_manifest,
-    proposer_delta_chunks_from_protocol, read_jesterky_manifest, record_manifest_validation,
-    run_turn, AgentTurnOutcome, CodexTurnRequest, NanoAgentTurnIdentity, NanoCodexExecution,
-    NanoCodexSessionPool, NanoCodexTurnRequest, OptimizerError, PromptProgram, Result,
-    SynthOptimizerConfig,
+    proposer_delta_chunks_from_protocol, proposer_uses_chatgpt_auth, read_jesterky_manifest,
+    record_manifest_validation, run_turn, AgentTurnOutcome, CodexTurnRequest,
+    NanoAgentTurnIdentity, NanoCodexExecution, NanoCodexSessionPool, NanoCodexTurnRequest,
+    OptimizerError, PromptProgram, Result, SynthOptimizerConfig,
 };
 
 const GEPA_REFLECTIVE_FRAME_SCHEMA_VERSION: &str = "gepa_reflective_frame.v1";
@@ -556,7 +556,26 @@ fn normalize_proposer_usage(config: &SynthOptimizerConfig, model: &str, usage: V
     let provider = config.proposer.provider.trim().to_ascii_lowercase();
     let model_lower = model.trim().to_ascii_lowercase();
     let reported_cost = usage_f64_from_map(&usage_map, "cost_usd")
-        .filter(|value| value.is_finite() && *value > 0.0);
+        .filter(|value| value.is_finite() && *value >= 0.0);
+    if proposer_uses_chatgpt_auth(&config.proposer.auth_mode) {
+        usage_map.insert(
+            "provider".to_string(),
+            Value::String("chatgpt_subscription".to_string()),
+        );
+        usage_map.insert("model".to_string(), Value::String(model.to_string()));
+        if reported_cost.is_none() {
+            // ChatGPT-authenticated Codex turns are subscription-backed rather
+            // than metered API calls. Record an explicit zero incremental API
+            // charge so the hard cost ledger does not mistake the absence of
+            // an API receipt for unknown spend.
+            usage_map.insert("cost_usd".to_string(), json!(0.0));
+            usage_map.insert(
+                "cost_source".to_string(),
+                Value::String("chatgpt_subscription_no_incremental_api_charge".to_string()),
+            );
+        }
+        return Value::Object(usage_map);
+    }
     if provider.eq_ignore_ascii_case("openrouter") && model_lower == OPENROUTER_GROK43_MODEL {
         return normalize_openrouter_grok43_usage(model, usage_map);
     }
@@ -3378,3 +3397,38 @@ fn non_empty(value: Option<&str>) -> Option<&str> {
         Some(value)
     }
 }
+
+#[cfg(test)]
+mod cost_tests {
+    use super::*;
+
+    #[test]
+    fn chatgpt_proposer_emits_explicit_zero_incremental_api_cost() {
+        let mut config = SynthOptimizerConfig::default();
+        config.proposer.auth_mode = "chatgpt".to_string();
+        let usage = normalize_proposer_usage(
+            &config,
+            "gpt-5.6-luna",
+            json!({"prompt_tokens": 100, "completion_tokens": 20, "total_tokens": 120}),
+        );
+        assert_eq!(usage.get("cost_usd"), Some(&json!(0.0)));
+        assert_eq!(
+            usage.get("cost_source"),
+            Some(&json!("chatgpt_subscription_no_incremental_api_charge"))
+        );
+        assert_eq!(usage.get("provider"), Some(&json!("chatgpt_subscription")));
+    }
+
+    #[test]
+    fn chatgpt_proposer_preserves_an_explicit_cost_receipt() {
+        let mut config = SynthOptimizerConfig::default();
+        config.proposer.auth_mode = "chatgpt".to_string();
+        let usage = normalize_proposer_usage(
+            &config,
+            "gpt-5.6-luna",
+            json!({"cost_usd": 0.25, "cost_source": "provider"}),
+        );
+        assert_eq!(usage.get("cost_usd"), Some(&json!(0.25)));
+        assert_eq!(usage.get("cost_source"), Some(&json!("provider")));
+    }
+}

{synth_optimizers-0.2.7.dev20260814 → synth_optimizers-0.2.9.dev20260814}/rust/crates/synth_gepa/src/lib.rs

@@ -3799,7 +3799,7 @@ fn consume_async_lane_work(
             | OptimizerJobStatus::Cancelled
             | OptimizerJobStatus::Expired => {
                 if let Some(outcome) =
-                    schedule_failed_rollout_retry_if_allowed(context, state, resources, &job)?
+                    schedule_failed_runtime_retry_if_allowed(context, state, resources, &job)?
                 {
                     if let Some(updated) =
                         state.cursor.pipeline_state.lane_leases.get_mut(&lease_key)
@@ -6956,7 +6956,7 @@ fn advance_pending_runtime_job(
                             });
                         }
                         if updated_job.status.is_terminal() {
-                            if let Some(outcome) = schedule_failed_rollout_retry_if_allowed(
+                            if let Some(outcome) = schedule_failed_runtime_retry_if_allowed(
                                 context,
                                 state,
                                 resources,
@@ -7078,7 +7078,7 @@ fn advance_pending_runtime_job(
         | OptimizerJobStatus::Cancelled
         | OptimizerJobStatus::Expired => {
             if let Some(outcome) =
-                schedule_failed_rollout_retry_if_allowed(context, state, resources, &job)?
+                schedule_failed_runtime_retry_if_allowed(context, state, resources, &job)?
             {
                 return Ok(outcome);
             }
@@ -9354,14 +9354,16 @@ fn consume_failed_rollout_attempt(
     Ok(())
 }
 
-fn schedule_failed_rollout_retry_if_allowed(
+fn schedule_failed_runtime_retry_if_allowed(
     context: &mut GepaRunContext,
     state: &mut GepaRunState,
     resources: &GepaStepResources,
     job: &OptimizerJob,
 ) -> Result<Option<GepaAdvanceOutcome>> {
-    if !matches!(job.kind, OptimizerJobKind::Rollout)
-        || matches!(job.status, OptimizerJobStatus::Cancelled)
+    if !matches!(
+        job.kind,
+        OptimizerJobKind::Rollout | OptimizerJobKind::Proposer
+    ) || matches!(job.status, OptimizerJobStatus::Cancelled)
     {
         return Ok(None);
     }
@@ -9391,7 +9393,7 @@ fn schedule_failed_rollout_retry_if_allowed(
         resources,
         state.cursor.phase.clone(),
         "retry_scheduled",
-        "scheduled GEPA failed rollout job retry",
+        "scheduled GEPA failed runtime job retry",
         Map::new(),
     )?;
     Ok(Some(GepaAdvanceOutcome {
@@ -9399,8 +9401,9 @@ fn schedule_failed_rollout_retry_if_allowed(
         terminal: false,
         result: None,
         message: format!(
-            "scheduled GEPA failed rollout job retry: {} attempt={}/{}",
+            "scheduled GEPA failed runtime job retry: {} kind={} attempt={}/{}",
             updated.job_id,
+            updated.kind.as_str(),
             updated.attempt.saturating_add(1),
             updated.retry_policy.max_attempts
         ),
@@ -20225,17 +20228,7 @@ fn record_runtime_effect_job(
     let mut job = OptimizerJob::new(input.job_id, input.run_id, input.kind);
     job.status = input.status;
     job.candidate_id = input.candidate_id.map(str::to_string);
-    if matches!(job.kind, OptimizerJobKind::Rollout) {
-        job.retry_policy = RetryPolicy {
-            max_attempts: 3,
-            backoff_seconds: 2,
-            retryable_failure_types: vec![
-                "synth_optimizer_http_error".to_string(),
-                "synth_optimizer_container_error".to_string(),
-                "synth_optimizer_failed".to_string(),
-            ],
-        };
-    }
+    job.retry_policy = runtime_effect_retry_policy(&job.kind);
     job.attempt = if matches!(job.status, OptimizerJobStatus::Pending) {
         input.effect.attempt.saturating_sub(1)
     } else {
@@ -20301,6 +20294,26 @@ fn record_runtime_effect_job(
     workspace.record_optimizer_job(&job)
 }
 
+fn runtime_effect_retry_policy(kind: &OptimizerJobKind) -> RetryPolicy {
+    match kind {
+        OptimizerJobKind::Rollout => RetryPolicy {
+            max_attempts: 3,
+            backoff_seconds: 2,
+            retryable_failure_types: vec![
+                "synth_optimizer_http_error".to_string(),
+                "synth_optimizer_container_error".to_string(),
+                "synth_optimizer_failed".to_string(),
+            ],
+        },
+        OptimizerJobKind::Proposer => RetryPolicy {
+            max_attempts: 2,
+            backoff_seconds: 2,
+            retryable_failure_types: vec!["synth_optimizer_proposer_error".to_string()],
+        },
+        _ => RetryPolicy::default(),
+    }
+}
+
 fn budget_exceeded_error(run_id: &str, breach: &BudgetLimitBreach) -> OptimizerError {
     OptimizerError::BudgetExceeded {
         run_id: run_id.to_string(),
@@ -21714,4 +21727,22 @@ mod run_loop_terminalization_tests {
             None
         );
     }
+
+    #[test]
+    fn proposer_runtime_jobs_get_one_bounded_retry() {
+        let policy = runtime_effect_retry_policy(&OptimizerJobKind::Proposer);
+        assert_eq!(policy.max_attempts, 2);
+        assert_eq!(policy.backoff_seconds, 2);
+        assert_eq!(
+            policy.retryable_failure_types,
+            vec!["synth_optimizer_proposer_error".to_string()]
+        );
+    }
+
+    #[test]
+    fn unrelated_runtime_jobs_keep_the_fail_closed_default() {
+        let policy = runtime_effect_retry_policy(&OptimizerJobKind::Annotation);
+        assert_eq!(policy.max_attempts, 1);
+        assert!(policy.retryable_failure_types.is_empty());
+    }
 }

{synth_optimizers-0.2.7.dev20260814 → synth_optimizers-0.2.9.dev20260814}/rust/crates/synth_gepa/src/runtime.rs

@@ -468,7 +468,7 @@ impl<'a> GepaRuntimeExecutor<'a> {
             Ok(outcome) => outcome,
             Err(error) => {
                 if let Some(retry) =
-                    self.schedule_rollout_retry_if_allowed(&running_job, &lease_id, &error)?
+                    self.schedule_runtime_retry_if_allowed(&running_job, &lease_id, &error)?
                 {
                     return Err(retry);
                 }
@@ -509,6 +509,7 @@ impl<'a> GepaRuntimeExecutor<'a> {
                 json!(self.config.gepa.rollout_submission_mode),
             );
         }
+        persist_runtime_outcome_before_completion(self.workspace, run_id, job_id, &outcome)?;
         record_runtime_effect_completed(
             self.workspace,
             RuntimeEffectCompletionInput {
@@ -527,14 +528,13 @@ impl<'a> GepaRuntimeExecutor<'a> {
         Ok(outcome)
     }
 
-    fn schedule_rollout_retry_if_allowed(
+    fn schedule_runtime_retry_if_allowed(
         &self,
         job: &OptimizerJob,
         lease_id: &str,
         error: &OptimizerError,
     ) -> Result<Option<OptimizerError>> {
-        if !matches!(job.kind, OptimizerJobKind::Rollout)
-            || !is_retryable_rollout_runtime_error(error)
+        if !is_retryable_runtime_job_error(job, error)
             || job.attempt >= job.retry_policy.max_attempts
         {
             return Ok(None);
@@ -555,8 +555,9 @@ impl<'a> GepaRuntimeExecutor<'a> {
             return Ok(None);
         };
         Ok(Some(OptimizerError::Failed(format!(
-            "retryable rollout runtime failure scheduled for retry job_id={} attempt={}/{} next_retry_at={}",
+            "retryable runtime failure scheduled for retry job_id={} kind={} attempt={}/{} next_retry_at={}",
             updated.job_id,
+            updated.kind.as_str(),
             updated.attempt.saturating_add(1),
             updated.retry_policy.max_attempts,
             updated.next_retry_at.unwrap_or_else(|| "now".to_string())
@@ -666,7 +667,7 @@ impl<'a> GepaRuntimeExecutor<'a> {
             .and_then(|usage| usage.get("cost_usd"))
             .or_else(|| response.get("cost_usd"))
             .and_then(Value::as_f64)
-            .filter(|value| value.is_finite() && *value > 0.0)
+            .filter(|value| value.is_finite() && *value >= 0.0)
             .or_else(|| proposer_static_cost_usd(self.config, &usage, &response));
         let cost_usd = reported_cost_usd.unwrap_or(0.0);
         let backend = response
@@ -1096,6 +1097,32 @@ fn is_retryable_rollout_runtime_error(error: &OptimizerError) -> bool {
     )
 }
 
+fn is_retryable_runtime_job_error(job: &OptimizerJob, error: &OptimizerError) -> bool {
+    match job.kind {
+        OptimizerJobKind::Rollout => is_retryable_rollout_runtime_error(error),
+        OptimizerJobKind::Proposer => matches!(error, OptimizerError::Proposer(_)),
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod runtime_job_retry_tests {
+    use super::*;
+
+    #[test]
+    fn proposer_errors_are_retryable_runtime_job_errors() {
+        let job = OptimizerJob::new("proposer-job", "run", OptimizerJobKind::Proposer);
+        assert!(is_retryable_runtime_job_error(
+            &job,
+            &OptimizerError::Proposer("app-server stalled".to_string())
+        ));
+        assert!(!is_retryable_runtime_job_error(
+            &job,
+            &OptimizerError::Config("invalid proposer config".to_string())
+        ));
+    }
+}
+
 fn dispatch_async_rollout(
     client: &ContainerClient,
     request: &Value,
@@ -1566,6 +1593,19 @@ fn ensure_job_lease(
     Ok(())
 }
 
+fn persist_runtime_outcome_before_completion(
+    workspace: &WorkspaceStore,
+    run_id: &str,
+    job_id: &str,
+    outcome: &RuntimeEffectOutcome,
+) -> Result<()> {
+    let stored = crate::stored_runtime_outcome(outcome)?;
+    let mut job = workspace.optimizer_job(run_id, job_id)?;
+    job.payload
+        .insert("runtime_outcome".to_string(), serde_json::to_value(stored)?);
+    workspace.record_optimizer_job(&job)
+}
+
 fn runtime_lease_id(worker_id: &str, job_id: &str) -> String {
     format!("lease_{worker_id}_{job_id}_{}", now_millis())
 }