synth-optimizers 0.2.9.dev20260814__tar.gz → 0.2.12__tar.gz

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-optimizers
-Version: 0.2.9.dev20260814
+Version: 0.2.12
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: synth-containers==0.4.1.dev20260814
 Requires-Dist: websocket-client>=1.8.0
@@ -43,12 +43,22 @@ contract.
 | --- | --- | --- | --- |
 | **GEPA** — reflective prompt evolution | Supported | [`rust/crates/synth_gepa/`](rust/crates/synth_gepa/) (Rust engine + service), [`src/synth_optimizers/gepa.py`](src/synth_optimizers/gepa.py) (Python API), [`skills/gepa/SKILL.md`](skills/gepa/SKILL.md) (agent runbook) | [Paper](https://arxiv.org/abs/2507.19457) · [gepa-ai docs](https://gepa-ai.github.io/gepa/) · bundled HTML via `gepa console` |
 | **GELO** — Go-Explore in prompt space (hosted) | Hosted submit | [`src/synth_optimizers/gelo.py`](src/synth_optimizers/gelo.py), [`skills/gelo/SKILL.md`](skills/gelo/SKILL.md), [`GELO_HOSTED_SDK_CLI_SPEC.md`](GELO_HOSTED_SDK_CLI_SPEC.md) | Bundled HTML via `gelo console` — [`src/synth_optimizers/docs/gelo/`](src/synth_optimizers/docs/gelo/) |
+| **SFT** — supervised fine-tuning (hosted) | Hosted submit | `HostedOptimizerClient.submit_sft()` / `submit_sft()` | Executed by the private Optimizers-beta runtime; the public client uses the shared hosted run API. |
 
 The shared [`synth_optimizer_platform`](rust/crates/synth_optimizer_platform/)
 crate is the substrate for optimizer implementations; GEPA is the first public
-local algorithm; GELO is hosted-only in the public package and runs on Synth
-hosted optimizer infrastructure.
-Hosted GEPA/GELO submission is covered in [`docs/hosted-optimizers.md`](docs/hosted-optimizers.md).
+local algorithm; GELO and SFT are hosted-only in the public package and run on
+Synth hosted optimizer infrastructure. Hosted GEPA, GELO, and SFT submission is
+covered in [`docs/hosted-optimizers.md`](docs/hosted-optimizers.md).
+
+## Future hosted-algorithm compatibility
+
+MAPO, OHCO, Online Reflexion, and MARL prompt-optimization identifiers are retained
+in [`future_algorithms.py`](src/synth_optimizers/future_algorithms.py) so clients can
+parse hosted catalogs and historical runs. They are **not supported public optimizer
+algorithms**: they carry no local executor, cookbook, or release commitment. New
+public algorithms graduate into the table above only after their public API contract,
+replay semantics, and end-to-end evidence are ready.
 
 ## Install
 
@@ -173,7 +183,7 @@ policy can stay on OpenAI. See [skills/gepa/SKILL.md](skills/gepa/SKILL.md) for
 
 - **OpenAI API key proposer** — run-local Codex home; does not use your host `~/.codex` login.
 - **OpenRouter proposer** — provider-aware Codex config and base URL; OpenRouter works for policy rollouts too.
-- **ChatGPT subscription proposer** — `auth_mode = "chatgpt"` with required `codex_home` (OAuth via [Codex CLI](https://github.com/openai/codex) or [opencode-openai-codex-auth](https://github.com/numman-ali/opencode-openai-codex-auth)); models include `gpt-5.4-mini`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`, `gpt-5.5`; proposer usage is $0, policy rollouts still bill normally.
+- **ChatGPT subscription proposer** — `auth_mode = "chatgpt"` with required `codex_home` (OAuth via [Codex CLI](https://github.com/openai/codex) or [opencode-openai-codex-auth](https://github.com/numman-ali/opencode-openai-codex-auth)); models include `gpt-5.4-mini`, `gpt-5.4`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`, `gpt-5.5`, `gpt-5.6-luna`, `gpt-5.6-sol`, and `gpt-5.6-terra`; proposer usage is $0, policy rollouts still bill normally.
 - **Nano-Codex proposer harness** — explicit `[proposer.nano_codex]` opt-in keeps one ChatGPT-authenticated app-server session warm across compatible GEPA generations, caches static task/program context by content digest, records monotonic JSONL events and typed turn receipts, and can replay receipts with zero live model or tool calls. See [`dev_examples/nano_codex_gepa/`](dev_examples/nano_codex_gepa/).
 - **Live usage** — `SYNTH_OPTIMIZERS_TERMINAL=1` prints running token and cost splits (`usage total=… policy=… proposer=…`).
 - **Docker proposer** — `runtime_substrate = "docker"` with `[proposer.docker].image`; workspaces stage under `~/.cache/synth-gepa-docker-workspaces/`, sync back, then cleanup; image: `docker/codex-gepa-proposer/Dockerfile`.

{synth_optimizers-0.2.9.dev20260814 → synth_optimizers-0.2.12}/README.md

@@ -21,12 +21,22 @@ contract.
 | --- | --- | --- | --- |
 | **GEPA** — reflective prompt evolution | Supported | [`rust/crates/synth_gepa/`](rust/crates/synth_gepa/) (Rust engine + service), [`src/synth_optimizers/gepa.py`](src/synth_optimizers/gepa.py) (Python API), [`skills/gepa/SKILL.md`](skills/gepa/SKILL.md) (agent runbook) | [Paper](https://arxiv.org/abs/2507.19457) · [gepa-ai docs](https://gepa-ai.github.io/gepa/) · bundled HTML via `gepa console` |
 | **GELO** — Go-Explore in prompt space (hosted) | Hosted submit | [`src/synth_optimizers/gelo.py`](src/synth_optimizers/gelo.py), [`skills/gelo/SKILL.md`](skills/gelo/SKILL.md), [`GELO_HOSTED_SDK_CLI_SPEC.md`](GELO_HOSTED_SDK_CLI_SPEC.md) | Bundled HTML via `gelo console` — [`src/synth_optimizers/docs/gelo/`](src/synth_optimizers/docs/gelo/) |
+| **SFT** — supervised fine-tuning (hosted) | Hosted submit | `HostedOptimizerClient.submit_sft()` / `submit_sft()` | Executed by the private Optimizers-beta runtime; the public client uses the shared hosted run API. |
 
 The shared [`synth_optimizer_platform`](rust/crates/synth_optimizer_platform/)
 crate is the substrate for optimizer implementations; GEPA is the first public
-local algorithm; GELO is hosted-only in the public package and runs on Synth
-hosted optimizer infrastructure.
-Hosted GEPA/GELO submission is covered in [`docs/hosted-optimizers.md`](docs/hosted-optimizers.md).
+local algorithm; GELO and SFT are hosted-only in the public package and run on
+Synth hosted optimizer infrastructure. Hosted GEPA, GELO, and SFT submission is
+covered in [`docs/hosted-optimizers.md`](docs/hosted-optimizers.md).
+
+## Future hosted-algorithm compatibility
+
+MAPO, OHCO, Online Reflexion, and MARL prompt-optimization identifiers are retained
+in [`future_algorithms.py`](src/synth_optimizers/future_algorithms.py) so clients can
+parse hosted catalogs and historical runs. They are **not supported public optimizer
+algorithms**: they carry no local executor, cookbook, or release commitment. New
+public algorithms graduate into the table above only after their public API contract,
+replay semantics, and end-to-end evidence are ready.
 
 ## Install
 
@@ -151,7 +161,7 @@ policy can stay on OpenAI. See [skills/gepa/SKILL.md](skills/gepa/SKILL.md) for
 
 - **OpenAI API key proposer** — run-local Codex home; does not use your host `~/.codex` login.
 - **OpenRouter proposer** — provider-aware Codex config and base URL; OpenRouter works for policy rollouts too.
-- **ChatGPT subscription proposer** — `auth_mode = "chatgpt"` with required `codex_home` (OAuth via [Codex CLI](https://github.com/openai/codex) or [opencode-openai-codex-auth](https://github.com/numman-ali/opencode-openai-codex-auth)); models include `gpt-5.4-mini`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`, `gpt-5.5`; proposer usage is $0, policy rollouts still bill normally.
+- **ChatGPT subscription proposer** — `auth_mode = "chatgpt"` with required `codex_home` (OAuth via [Codex CLI](https://github.com/openai/codex) or [opencode-openai-codex-auth](https://github.com/numman-ali/opencode-openai-codex-auth)); models include `gpt-5.4-mini`, `gpt-5.4`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`, `gpt-5.5`, `gpt-5.6-luna`, `gpt-5.6-sol`, and `gpt-5.6-terra`; proposer usage is $0, policy rollouts still bill normally.
 - **Nano-Codex proposer harness** — explicit `[proposer.nano_codex]` opt-in keeps one ChatGPT-authenticated app-server session warm across compatible GEPA generations, caches static task/program context by content digest, records monotonic JSONL events and typed turn receipts, and can replay receipts with zero live model or tool calls. See [`dev_examples/nano_codex_gepa/`](dev_examples/nano_codex_gepa/).
 - **Live usage** — `SYNTH_OPTIMIZERS_TERMINAL=1` prints running token and cost splits (`usage total=… policy=… proposer=…`).
 - **Docker proposer** — `runtime_substrate = "docker"` with `[proposer.docker].image`; workspaces stage under `~/.cache/synth-gepa-docker-workspaces/`, sync back, then cleanup; image: `docker/codex-gepa-proposer/Dockerfile`.

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

@@ -1,6 +1,6 @@
 [project]
 name = "synth-optimizers"
-version = "0.2.9.dev20260814"
+version = "0.2.12"
 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.9.dev20260814 → synth_optimizers-0.2.12}/rust/crates/synth_gepa/openapi/gepa-service-v1.yaml

@@ -32,6 +32,28 @@ servers:
     description: Local single-workspace server
 
 paths:
+  /v1/optimizer/capabilities:
+    get:
+      operationId: getOptimizerCapabilities
+      summary: Advertise Workshop optimizer compatibility
+      responses:
+        '200':
+          description: Optimizer algorithms, recipes, and runtime capabilities.
+          content:
+            application/json:
+              schema: { $ref: '#/components/schemas/OptimizerCapabilities' }
+
+  /v1/optimizer/status:
+    get:
+      operationId: getOptimizerStatus
+      summary: Return the Workshop-compatible optimizer status document
+      responses:
+        '200':
+          description: Alias of the optimizer capability document for compatibility.
+          content:
+            application/json:
+              schema: { $ref: '#/components/schemas/OptimizerCapabilities' }
+
   # ---------------------------------------------------------------------------
   # Submission + lifecycle
   # ---------------------------------------------------------------------------
@@ -648,7 +670,6 @@ paths:
 
 # =============================================================================
 components:
-
   parameters:
     RunId:
       name: run_id
@@ -698,6 +719,25 @@ components:
           schema: { $ref: '#/components/schemas/ErrorEnvelope' }
 
   schemas:
+    OptimizerCapabilities:
+      type: object
+      required: [status, algorithms, recipes, replay, cancellation, compatibleTemplateIds]
+      properties:
+        status: { type: string, const: ok }
+        algorithms:
+          type: array
+          minItems: 1
+          items: { type: string }
+        recipes:
+          type: array
+          minItems: 1
+          items: { type: string }
+        replay: { type: boolean }
+        cancellation: { type: boolean }
+        compatibleTemplateIds:
+          type: array
+          minItems: 1
+          items: { type: string }
 
     # ---- Enums -------------------------------------------------------------
     RunStatus:

{synth_optimizers-0.2.9.dev20260814 → synth_optimizers-0.2.12}/rust/crates/synth_gepa/src/service.rs

@@ -1508,6 +1508,9 @@ fn route_request(request: HttpRequest, runtime: GepaServiceRuntime) -> HttpRespo
     let config = &runtime.config;
     match (request.method.as_str(), segments.as_slice()) {
         ("GET", ["health"]) => json_response(200, &json!({"status": "ok"})),
+        ("GET", ["v1", "optimizer", "capabilities"]) | ("GET", ["v1", "optimizer", "status"]) => {
+            json_response(200, &optimizer_capabilities_payload())
+        }
         ("GET", ["whoami"]) => json_response(
             200,
             &service_identity_payload(config, &runtime.service_url, &runtime.started_at, None),
@@ -1583,15 +1586,65 @@ fn route_request(request: HttpRequest, runtime: GepaServiceRuntime) -> HttpRespo
             Ok(None) => run_not_found_response(run_id),
             Err(error) => optimizer_error_response(error),
         },
+        // `route_not_found`, not `run_not_found`. They share a status but mean
+        // opposite things to a client polling a live run: a run that is not
+        // indexed yet may appear at any moment, while a route that does not
+        // exist never will. Reusing the run code told Workshop to keep retrying
+        // a route this build does not serve for as long as the run lasted,
+        // paying for rollouts whose events could never be read.
         _ => error_response(
             404,
-            "run_not_found",
+            "route_not_found",
             &format!("route not found: {} {}", request.method, path),
             None,
         ),
     }
 }
 
+/// What this service can do, answered by this service.
+///
+/// Two rules, both learned from the handshake gap that blocked v0.4:
+///
+/// 1. **Only facts this runtime owns.** Recipe ids and visual template ids are
+///    Workshop's vocabulary — they appear nowhere in this crate and only ever
+///    reached it because Workshop's install payload supplied them. Echoing them
+///    back proves nothing except that we were told what to say, and would tie a
+///    plugin release to every new host template. Workshop resolves those itself.
+/// 2. **Derived, never asserted.** `replay` and `cancellation` are read off the
+///    router below rather than written as literals, so they cannot claim a
+///    capability this build does not serve. A hand-written `replay: true` is
+///    true only by accident of which branch it was cut from.
+fn optimizer_capabilities_payload() -> Value {
+    json!({
+        "status": "ok",
+        "contractVersion": OPTIMIZER_CONTRACT_VERSION,
+        "serviceVersion": env!("CARGO_PKG_VERSION"),
+        "algorithms": ["gepa"],
+        "replay": documents_route("/runs/{run_id}/optimizer-events"),
+        "cancellation": documents_route("/runs/{run_id}/cancel"),
+    })
+}
+
+/// Workshop's capability contract revision this service implements.
+const OPTIMIZER_CONTRACT_VERSION: &str = "optimizer.contract.v1";
+
+/// Is this route in the spec this build ships and serves at `/openapi.yaml`?
+///
+/// Not a second list to keep in step: the spec is a real artifact compiled into
+/// the binary and served to clients, so answering from it means a capability
+/// claim and the published contract cannot disagree. A hand-written
+/// `replay: true` has no such tether — it stays `true` when the route is
+/// dropped, or when the payload is copied to a branch that never had it, which
+/// is precisely how a green handshake ends up in front of a missing endpoint.
+///
+/// `router_and_spec_agree` closes the remaining gap by checking the spec
+/// against what the router actually serves.
+fn documents_route(path: &str) -> bool {
+    GEPA_SERVICE_OPENAPI_YAML
+        .lines()
+        .any(|line| line.trim_end().trim_end_matches(':').trim() == path)
+}
+
 fn handle_websocket_connection(
     stream: &mut TcpStream,
     runtime: GepaServiceRuntime,
@@ -5772,6 +5825,210 @@ mod tests {
         );
     }
 
+    #[test]
+    /// The handshake answers for this service and nothing else.
+    ///
+    /// The previous form of this test read the payload's own literals back and
+    /// asserted they were non-empty strings — it tested the constant against
+    /// itself, and would have stayed green with `replay: true` on a build
+    /// serving no events route. Assert the two properties that can actually be
+    /// wrong instead: that we do not speak for Workshop, and that every boolean
+    /// is tied to a route this build ships.
+    #[test]
+    fn workshop_capability_handshake_answers_only_for_this_service() {
+        let capabilities = optimizer_capabilities_payload();
+
+        // Workshop's vocabulary. This service does not define recipe ids or
+        // visual template ids and must not claim to.
+        for host_owned in ["recipes", "compatibleTemplateIds"] {
+            assert!(
+                capabilities.get(host_owned).is_none(),
+                "capabilities must not answer for Workshop's `{host_owned}`"
+            );
+        }
+
+        let algorithms = capabilities["algorithms"].as_array().unwrap();
+        assert!(!algorithms.is_empty());
+        assert!(algorithms.iter().all(Value::is_string));
+        assert!(algorithms.iter().any(|id| id == "gepa"));
+        assert_eq!(capabilities["contractVersion"], OPTIMIZER_CONTRACT_VERSION);
+        assert_eq!(capabilities["serviceVersion"], env!("CARGO_PKG_VERSION"));
+
+        // Every boolean is derived from the shipped spec, so it cannot outlive
+        // the route it describes.
+        assert_eq!(
+            capabilities["replay"],
+            documents_route("/runs/{run_id}/optimizer-events")
+        );
+        assert_eq!(
+            capabilities["cancellation"],
+            documents_route("/runs/{run_id}/cancel")
+        );
+        assert_eq!(capabilities["replay"], true);
+        assert_eq!(capabilities["cancellation"], true);
+
+        // The derivation has to be capable of saying no, or it is a literal
+        // wearing a function's clothes.
+        assert!(!documents_route("/runs/{run_id}/route-that-does-not-exist"));
+    }
+
+    /// The spec backs the capability booleans, so a route the router serves but
+    /// the spec omits would let a true claim rest on a stale document — and a
+    /// route the spec claims but the router drops would make it simply false.
+    #[test]
+    fn router_and_spec_agree_on_the_capability_routes() {
+        for path in [
+            "/health",
+            "/runs/{run_id}/optimizer-events",
+            "/runs/{run_id}/cancel",
+            "/v1/optimizer/capabilities",
+        ] {
+            assert!(
+                documents_route(path),
+                "{path} is served but missing from gepa-service-v1.yaml"
+            );
+        }
+    }
+
+    /// Drive the real service over a real socket.
+    ///
+    /// Everything above inspects functions and constants. This starts
+    /// `run_gepa_service` on a loopback port and speaks HTTP to it, so the
+    /// routes are asserted the way Workshop reaches them. The gap this closes
+    /// is the one that cost v0.4 an acceptance run: every test on both sides
+    /// passed while the endpoint Workshop required did not exist, because
+    /// nothing on either side had ever spoken to the other over a socket.
+    #[test]
+    fn the_running_service_answers_the_workshop_contract() {
+        use std::io::{Read, Write};
+        use std::net::TcpStream;
+
+        let db = scratch_path("contract");
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        let addr = listener.local_addr().unwrap();
+        drop(listener);
+        let mut config = GepaServiceConfig::new(db, addr.to_string());
+        config.worker_count = 1;
+        thread::spawn(move || {
+            let _ = run_gepa_service(config);
+        });
+
+        let get = |path: &str| -> (u16, String) {
+            // The service is starting concurrently; retry briefly rather than
+            // race it.
+            for attempt in 0..50 {
+                let Ok(mut stream) = TcpStream::connect(addr) else {
+                    thread::sleep(Duration::from_millis(40));
+                    continue;
+                };
+                let request =
+                    format!("GET {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n");
+                if stream.write_all(request.as_bytes()).is_err() {
+                    thread::sleep(Duration::from_millis(40));
+                    continue;
+                }
+                let mut raw = String::new();
+                if stream.read_to_string(&mut raw).is_err() && attempt < 49 {
+                    thread::sleep(Duration::from_millis(40));
+                    continue;
+                }
+                let status = raw
+                    .split_whitespace()
+                    .nth(1)
+                    .and_then(|code| code.parse().ok())
+                    .unwrap_or(0);
+                let body = raw.split("\r\n\r\n").nth(1).unwrap_or("").to_string();
+                return (status, body);
+            }
+            panic!("service never accepted a connection on {addr}");
+        };
+
+        let (status, body) = get("/health");
+        assert_eq!(status, 200, "/health: {body}");
+
+        // The route whose absence blocked v0.4.
+        let (status, body) = get("/v1/optimizer/capabilities");
+        assert_eq!(status, 200, "/v1/optimizer/capabilities: {body}");
+        let capabilities: Value = serde_json::from_str(&body).unwrap();
+        assert!(capabilities["algorithms"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|id| id == "gepa"));
+        assert_eq!(capabilities["replay"], true);
+        assert_eq!(capabilities["cancellation"], true);
+        assert!(capabilities.get("recipes").is_none());
+        assert!(capabilities.get("compatibleTemplateIds").is_none());
+
+        // Served, and 404s for an unknown run rather than for an unknown route.
+        let (status, body) = get("/runs/no_such_run/optimizer-events?after_sequence=0&limit=10");
+        assert_eq!(status, 404, "unexpected status for a missing run: {body}");
+        let error: Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(
+            error["error"]["code"], "run_not_found",
+            "a served route with a missing run must say run_not_found: {body}"
+        );
+
+        // And an unknown route is reported as such, so a client can tell "this
+        // build cannot do that" from "not indexed yet".
+        let (status, body) = get("/runs/no_such_run/not-a-route");
+        assert_eq!(status, 404);
+        let error: Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(
+            error["error"]["code"], "route_not_found",
+            "an unknown route must not masquerade as a missing run: {body}"
+        );
+    }
+
+    /// The wheel version and the crate version are set in different files and
+    /// neither is derived from the other, so only a test keeps them in step.
+    ///
+    /// `/whoami` and the capability handshake both report `CARGO_PKG_VERSION`.
+    /// When only `pyproject.toml` is bumped, an installed 0.2.12 wheel reports
+    /// itself as 0.2.9 over HTTP, and every version floor keyed on that number
+    /// is checking a value the release never had.
+    #[test]
+    fn the_wheel_and_the_crate_report_the_same_release() {
+        let pyproject = include_str!("../../../../pyproject.toml");
+        let declared = pyproject
+            .lines()
+            .find_map(|line| line.trim().strip_prefix("version = "))
+            .map(|value| value.trim().trim_matches('"'))
+            .expect("pyproject version");
+        // PEP 440 pre-release suffixes (`0.2.12.dev20260816`) have no Cargo
+        // equivalent; the release triple in front of them must still match.
+        let release: String = declared
+            .split('.')
+            .take(3)
+            .collect::<Vec<_>>()
+            .join(".");
+        assert_eq!(
+            release,
+            env!("CARGO_PKG_VERSION"),
+            "pyproject.toml ({declared}) and the workspace Cargo.toml disagree; \
+             /whoami and the capability handshake report the Cargo value"
+        );
+    }
+
+    /// An unknown route is not a missing run. Workshop retries the latter for
+    /// the life of a paid run and fails fast on the former.
+    #[test]
+    fn unknown_routes_are_not_reported_as_missing_runs() {
+        let source = include_str!("service.rs");
+        let router = source
+            .split("fn optimizer_capabilities_payload")
+            .next()
+            .expect("router source");
+        let fallback = router
+            .rfind("route not found: ")
+            .expect("router fallback arm");
+        let arm = &router[fallback.saturating_sub(200)..fallback];
+        assert!(
+            arm.contains("route_not_found"),
+            "the router fallback must report route_not_found, not run_not_found"
+        );
+    }
+
     #[test]
     fn optimizer_event_pages_are_cursor_idempotent_and_run_isolated() {
         let path = scratch_path("cursor");

{synth_optimizers-0.2.9.dev20260814 → synth_optimizers-0.2.12}/rust/crates/synth_optimizer_platform/src/config.rs

@@ -1252,6 +1252,7 @@ pub const CHATGPT_PROPOSER_MODELS: &[&str] = &[
     "gpt-5.5",
     "gpt-5.6-luna",
     "gpt-5.6-sol",
+    "gpt-5.6-terra",
 ];
 
 pub fn proposer_auth_mode_normalized(auth_mode: &str) -> String {
@@ -2895,8 +2896,8 @@ mod tests {
     use super::*;
 
     #[test]
-    fn locked_luna_and_sol_chatgpt_proposers_are_allowed() {
-        for model in ["gpt-5.6-luna", "gpt-5.6-sol"] {
+    fn locked_5_6_chatgpt_proposers_are_allowed() {
+        for model in ["gpt-5.6-luna", "gpt-5.6-sol", "gpt-5.6-terra"] {
             assert!(CHATGPT_PROPOSER_MODELS.contains(&model));
             validate_chatgpt_proposer_model(model).expect("locked ChatGPT proposer model");
             validate_chatgpt_proposer_model(&model.to_ascii_uppercase())
@@ -2911,6 +2912,7 @@ mod tests {
         assert!(error.to_string().contains("not allowed"));
         assert!(error.to_string().contains("gpt-5.6-luna"));
         assert!(error.to_string().contains("gpt-5.6-sol"));
+        assert!(error.to_string().contains("gpt-5.6-terra"));
     }
 
     #[test]

{synth_optimizers-0.2.9.dev20260814 → synth_optimizers-0.2.12}/src/synth_optimizers/__init__.py

@@ -79,10 +79,16 @@ from .hosted import (
     OptimizerStartupCatalog,
     RunStatus as HostedRunStatus,
     submit_mapo,
+    submit_sft,
     submit_online_reflexion,
     validate_online_reflexion_evidence_notes,
 )
 from .hosted_config import HostedOptimizerConfig
+from .future_algorithms import (
+    FUTURE_HOSTED_ALGORITHMS,
+    FutureHostedAlgorithm,
+    FutureHostedAlgorithmSlug,
+)
 from .o11y import (
     LiveProgress,
     RegistryRecord,
@@ -220,6 +226,9 @@ __all__ = [
     "HostedOptimizerClient",
     "HostedOptimizerError",
     "HostedOptimizerConfig",
+    "FUTURE_HOSTED_ALGORITHMS",
+    "FutureHostedAlgorithm",
+    "FutureHostedAlgorithmSlug",
     "HostedRunStatus",
     "InvariantError",
     "InMemoryRunLog",
@@ -287,6 +296,7 @@ __all__ = [
     "gepa_delete_run_storage",
     "gepa_serve",
     "submit_mapo",
+    "submit_sft",
     "submit_online_reflexion",
     "validate_online_reflexion_evidence_notes",
 ]

{synth_optimizers-0.2.9.dev20260814 → synth_optimizers-0.2.12}/src/synth_optimizers/docs/gepa/algorithms/20-proposer-and-policies.md

@@ -18,7 +18,7 @@ The proposer is a Codex app-server. Configure it under `[proposer]` (TOML) or
 | `runtime_substrate` | `local` (host) or `docker` (`[proposer.docker].image`). |
 | `provider` | `openai`, `openrouter`, `deepseek`. |
 | `auth_mode` | `auto`, `api_key`, `chatgpt`, or `host`. |
-| `model` | e.g. `gpt-5.4-nano`, `gpt-5.4-mini`, `gpt-5.5`. |
+| `model` | e.g. `gpt-5.4-mini`, `gpt-5.5`, `gpt-5.6-luna`, `gpt-5.6-sol`, `gpt-5.6-terra`. |
 | `reasoning_effort` | `none` / `low` / `medium` / `high`. |
 | `execution_mode` | `local_process` / `stdio` (JSON-RPC over stdin/stdout) or `websocket` / `ws`. |
 | `service_tier` | `default` or `fast` (Codex Fast mode; requires ChatGPT auth). |

synth_optimizers-0.2.12/src/synth_optimizers/future_algorithms.py

@@ -0,0 +1,39 @@
+"""Compatibility identifiers for hosted algorithms not yet publicly supported.
+
+These identifiers let the SDK parse a hosted catalog and preserve run history without
+implying that the package provides a supported local executor, cookbook, or release
+commitment.  Promote an entry only when its public contract and end-to-end evidence
+are ready.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class FutureHostedAlgorithmSlug(StrEnum):
+    MAPO = "mapo"
+    OHCO = "ohco"
+    ONLINE_REFLEXION = "online-reflexion"
+    MARL_PROMPTOPT = "marl-promptopt"
+
+
+@dataclass(frozen=True, slots=True)
+class FutureHostedAlgorithm:
+    slug: FutureHostedAlgorithmSlug
+    summary: str
+
+
+FUTURE_HOSTED_ALGORITHMS: tuple[FutureHostedAlgorithm, ...] = (
+    FutureHostedAlgorithm(FutureHostedAlgorithmSlug.MAPO, "Private hosted compatibility lane."),
+    FutureHostedAlgorithm(FutureHostedAlgorithmSlug.OHCO, "Private hosted compatibility lane."),
+    FutureHostedAlgorithm(
+        FutureHostedAlgorithmSlug.ONLINE_REFLEXION,
+        "Gated hosted compatibility lane pending release evidence.",
+    ),
+    FutureHostedAlgorithm(
+        FutureHostedAlgorithmSlug.MARL_PROMPTOPT,
+        "Research executable; not a public hosted product lane.",
+    ),
+)

{synth_optimizers-0.2.9.dev20260814 → synth_optimizers-0.2.12}/src/synth_optimizers/hosted.py

@@ -85,6 +85,7 @@ _USAGE_REGISTRATION_TIMEOUT_SECONDS = 2.0
 class OptimizerAlgorithmSlug(StrEnum):
     GEPA = "gepa"
     GELO = "go-ex"
+    SFT = "sft"
     MAPO = "mapo"
     OHCO = "ohco"
     ONLINE_REFLEXION = "online-reflexion"
@@ -392,6 +393,14 @@ class HostedOptimizerClient:
     ) -> OptimizerRunSubmitResponse:
         return self._submit(OptimizerAlgorithmSlug.GELO, config, **kwargs)
 
+    def submit_sft(
+        self,
+        config: Mapping[str, Any] | Any,
+        **kwargs: Any,
+    ) -> OptimizerRunSubmitResponse:
+        """Submit a hosted SFT run executed by the Optimizers-beta backend."""
+        return self._submit(OptimizerAlgorithmSlug.SFT, config, **kwargs)
+
     def submit_mapo(
         self,
         config: Mapping[str, Any] | Any,
@@ -983,6 +992,17 @@ def submit_mapo(
     return active_client.submit_mapo(config, **kwargs)
 
 
+def submit_sft(
+    config: Mapping[str, Any] | Any,
+    *,
+    client: HostedOptimizerClient | None = None,
+    **kwargs: Any,
+) -> OptimizerRunSubmitResponse:
+    """Submit an SFT run through the public hosted Optimizers API."""
+    active_client = client or HostedOptimizerClient()
+    return active_client.submit_sft(config, **kwargs)
+
+
 def submit_online_reflexion(
     config: Mapping[str, Any] | Any,
     *,