superqode 2.4.5__tar.gz → 2.4.6__tar.gz

{superqode-2.4.5 → superqode-2.4.6}/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to SuperQode will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.6] - 2026-09-19
+
+### SystemOne Tune
+
+- Remember the reflection model (OpenAI, Anthropic, Gemini, or any provider/model) across Install and TUI restart via `~/.superqode/tune-preferences.json`.
+- Probe GEPA as soon as `:systemone tune` opens; highlight Install before you fill the form.
+- After Install, refresh imports so a TUI restart is only needed when this process still cannot load GEPA.
+- Default Gemini reflection model stays `gemini/gemini-3.6-flash` (2.5 is retired for new users).
+
 ## [2.4.5] - 2026-09-19
 
 ### SystemOne Tune

{superqode-2.4.5 → superqode-2.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.5
+Version: 2.4.6
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

superqode-2.4.6/examples/tune/README.md

@@ -0,0 +1,8 @@
+# Free SystemOne Tune demo data
+
+Original synthetic routing tickets for the `factory_route` pack.
+No third-party corpus. Free to use in demos and tests.
+
+- `factory-route-free.csv`: 70 labeled examples (35 train / 35 test)
+- Columns: `id`, `state`, `label`, `split`, `rationale`
+- Labels: `private`, `local`, `cheap`, `best`, `review`, `long-context`, `no-subscription`

{superqode-2.4.5 → superqode-2.4.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.4.5"
+version = "2.4.6"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.4.5 → superqode-2.4.6}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.4.5"
+__version__ = "2.4.6"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.4.5 → superqode-2.4.6}/src/superqode/systemone/tune.py

@@ -37,8 +37,33 @@ class TuneCancelled(Exception):
     """A user stopped a tuning experiment."""
 
 
+def tuning_support_available() -> bool:
+    """True when GEPA optimize_anything imports in this process."""
+    try:
+        from gepa.optimize_anything import OptimizeAnythingConfig, optimize_anything  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
+def refresh_tuning_support_import() -> bool:
+    """Clear stale import failures so a just-installed GEPA can load without restart."""
+    import importlib
+    import sys
+
+    for name in list(sys.modules):
+        if name == "gepa" or name.startswith("gepa."):
+            del sys.modules[name]
+    importlib.invalidate_caches()
+    return tuning_support_available()
+
+
 def install_support() -> str:
-    """Explicit setup action targeting SuperQode's own Python environment."""
+    """Explicit setup action targeting SuperQode's own Python environment.
+
+    Installs GEPA (and light deps) into the same interpreter SuperQode is running.
+    After install we refresh imports so most users can continue without restarting the TUI.
+    """
     import shlex
     import subprocess
     from superqode.providers.env_introspect import python_package_install_command
@@ -55,8 +80,15 @@ def install_support() -> str:
         raise ValueError(
             "Tuning support installation failed. Check Git access to github.com/gepa-ai/gepa and package-index access."
         )
+    if refresh_tuning_support_import():
+        return (
+            "Tuning support is ready in this session. You can Prepare examples and Start without restarting. "
+            "Your reflection model preference is saved automatically."
+        )
     return (
-        "Tuning support installed. Restart SuperQode before tuning; saved judgments can be resumed."
+        "Tuning support installed, but this session still cannot import it. "
+        "Restart SuperQode once, then open :systemone tune again. "
+        "Your reflection model preference is restored automatically; saved judgments can be resumed."
     )
 
 
@@ -70,12 +102,49 @@ class TuneOptions:
     seed: int = 0
 
 
+def tune_preferences_path() -> Path:
+    """User preference file for Tune UI defaults (no secrets)."""
+    return Path.home() / ".superqode" / "tune-preferences.json"
+
+
+def load_tune_preferences() -> dict:
+    path = tune_preferences_path()
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def save_tune_preferences(**updates: str | int | float) -> None:
+    """Persist non-secret Tune UI choices across restarts (reflection model, budgets)."""
+    path = tune_preferences_path()
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    current = load_tune_preferences()
+    for key, value in updates.items():
+        if value is None or value == "":
+            current.pop(key, None)
+        else:
+            current[key] = value
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(json.dumps(current, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    temporary.replace(path)
+
+
+def preferred_reflection_model() -> str:
+    """Last Tune reflection model if set; otherwise credential-based default."""
+    saved = str(load_tune_preferences().get("reflection_lm") or "").strip()
+    return saved or default_reflection_model()
+
+
 def default_reflection_model() -> str:
     """Select only a provider with configured credentials, never subscription auth."""
     for key, model in (
         ("OPENAI_API_KEY", "openai/gpt-4.1-mini"),
         ("ANTHROPIC_API_KEY", "anthropic/claude-sonnet-4-6"),
-        ("GEMINI_API_KEY", "gemini/gemini-2.5-flash"),
+        ("GEMINI_API_KEY", "gemini/gemini-3.6-flash"),
     ):
         if os.environ.get(key):
             return model
@@ -410,7 +479,7 @@ def preflight(manifest: dict, *, check_gepa: bool = True) -> dict:
             from gepa.optimize_anything import OptimizeAnythingConfig, optimize_anything  # noqa: F401
         except ImportError as exc:
             raise ValueError(
-                "Tuning support is not installed or is out of date. Run: superqode harness tune --setup, then restart SuperQode."
+                "Tuning support is not installed. Click Install tuning support in this screen, or run: superqode harness tune --setup."
             ) from exc
     return {
         "endpoint": settings.endpoint,

{superqode-2.4.5 → superqode-2.4.6}/src/superqode/widgets/systemone_tune.py

@@ -81,7 +81,7 @@ class SystemOneTuneScreen(Screen[str | None]):
             with Vertical(id="tune-limits"):
                 yield Static("Experiment limits")
                 yield Input(
-                    value=tune.default_reflection_model(),
+                    value=tune.preferred_reflection_model(),
                     placeholder="Reflection model: provider/model",
                     id="tune-model",
                 )
@@ -111,6 +111,43 @@ class SystemOneTuneScreen(Screen[str | None]):
     def on_mount(self) -> None:
         for selector in ("#tune-review", "#tune-start", "#tune-use", "#tune-diff"):
             self.query_one(selector).display = False
+        prefs = tune.load_tune_preferences()
+        model = str(prefs.get("reflection_lm") or tune.preferred_reflection_model()).strip()
+        if model:
+            self.query_one("#tune-model", Input).value = model
+        if "max_evals" in prefs:
+            self.query_one("#tune-evals", Input).value = str(prefs["max_evals"])
+        if "max_reflection_cost" in prefs:
+            self.query_one("#tune-cost", Input).value = str(prefs["max_reflection_cost"])
+        self._refresh_support_status()
+
+    def _refresh_support_status(self) -> None:
+        ready = tune.tuning_support_available()
+        install_btn = self.query_one("#tune-install", Button)
+        install_btn.disabled = ready
+        if ready:
+            self._status("Tuning support is ready. Fill the pack and examples, then Prepare.")
+        else:
+            self._status(
+                "Tuning support (GEPA) is not installed yet. Click Install tuning support before Start. Prepare and labeling work without it."
+            )
+            install_btn.variant = "primary"
+
+    def _remember_preferences(self) -> None:
+        model = self._value("model") or tune.preferred_reflection_model()
+        updates: dict = {}
+        if model:
+            updates["reflection_lm"] = model
+        try:
+            updates["max_evals"] = int(self._value("evals"))
+        except ValueError:
+            pass
+        try:
+            updates["max_reflection_cost"] = float(self._value("cost"))
+        except ValueError:
+            pass
+        if updates:
+            tune.save_tune_preferences(**updates)
 
     def _value(self, name: str) -> str:
         return self.query_one(f"#tune-{name}", Input).value.strip()
@@ -121,6 +158,7 @@ class SystemOneTuneScreen(Screen[str | None]):
     @on(Button.Pressed, "#tune-prepare")
     def prepare(self) -> None:
         try:
+            self._remember_preferences()
             resume = self._value("resume")
             if resume:
                 self.output = Path(resume).expanduser()
@@ -129,7 +167,7 @@ class SystemOneTuneScreen(Screen[str | None]):
                 options = tune.TuneOptions(
                     pack=self._value("pack"),
                     spec=self._value("spec"),
-                    reflection_lm=self._value("model") or tune.default_reflection_model(),
+                    reflection_lm=self._value("model") or tune.preferred_reflection_model(),
                     max_evals=int(self._value("evals")),
                     max_reflection_cost=float(self._value("cost")),
                 )
@@ -221,8 +259,14 @@ class SystemOneTuneScreen(Screen[str | None]):
         if self.running:
             return
         try:
+            self._remember_preferences()
+            if not tune.tuning_support_available():
+                self._status(
+                    "Install tuning support first, then Start. No restart is usually required after Install succeeds."
+                )
+                return
             self.manifest["options"].update(
-                reflection_lm=self._value("model") or tune.default_reflection_model(),
+                reflection_lm=self._value("model") or tune.preferred_reflection_model(),
                 max_evals=int(self._value("evals")),
                 max_reflection_cost=float(self._value("cost")),
             )
@@ -236,7 +280,11 @@ class SystemOneTuneScreen(Screen[str | None]):
         self.query_one("#tune-start", Button).disabled = True
         self.query_one("#tune-limits").display = False
         self.query_one("#tune-back", Button).label = "Stop"
-        self._status(f"Starting · {details['model']} at {details['endpoint']}")
+        self._status(
+            "Starting · reflection "
+            f"{details.get('reflection_model') or details.get('model')} · "
+            f"Jev {details.get('model')} at {details.get('endpoint')}"
+        )
         self._run()
 
     @work(thread=True, exclusive=True)
@@ -261,6 +309,7 @@ class SystemOneTuneScreen(Screen[str | None]):
     def install(self) -> None:
         if self.running:
             return
+        self._remember_preferences()
         self.running = True
         self.installing = True
         for name in ("install", "start", "prepare", "back"):
@@ -281,8 +330,13 @@ class SystemOneTuneScreen(Screen[str | None]):
     def _installation_finished(self, message: str) -> None:
         self.running = False
         self.installing = False
-        self.query_one("#tune-back", Button).disabled = False
-        self._status(message + (f"\nSaved judgments: {self.output}" if self.output else ""))
+        for name in ("install", "start", "prepare", "back"):
+            try:
+                self.query_one(f"#tune-{name}", Button).disabled = False
+            except Exception:
+                pass
+        self._refresh_support_status()
+        self._status(message + ("\nSaved judgments: " + str(self.output) if self.output else ""))
 
     def _finished(self, report: dict) -> None:
         self.report = report

{superqode-2.4.5 → superqode-2.4.6}/src/superqode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.5
+Version: 2.4.6
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.5 → superqode-2.4.6}/src/superqode.egg-info/SOURCES.txt

@@ -65,6 +65,7 @@ examples/rlm-demo/deploy_audit/report.py
 examples/rlm-demo/tests/test_report.py
 examples/systemone/rubric-eval.yaml
 examples/systemone/ticket-triage-pack.yaml
+examples/tune/README.md
 scripts/check_release_metadata.py
 src/superqode/__init__.py
 src/superqode/acp_discovery.py
@@ -1066,6 +1067,7 @@ tests/test_tui_mounted.py
 tests/test_tui_onboarding.py
 tests/test_tui_smoke.py
 tests/test_tui_tool_display.py
+tests/test_tune_preferences.py
 tests/test_uhp_backend.py
 tests/test_uhp_client.py
 tests/test_uhp_connect.py

{superqode-2.4.5 → superqode-2.4.6}/tests/test_systemone_tune.py

@@ -425,8 +425,15 @@ async def test_tui_completed_run_exposes_diff_but_not_pilot_adoption(tmp_path):
 @pytest.mark.asyncio
 async def test_tui_start_worker_produces_report(tmp_path, monkeypatch):
     out = prepare(tmp_path)
+    monkeypatch.setattr(tune, "tuning_support_available", lambda: True)
     monkeypatch.setattr(
-        tune, "preflight", lambda *args, **kwargs: {"model": "fake", "endpoint": "local test"}
+        tune,
+        "preflight",
+        lambda *args, **kwargs: {
+            "model": "fake",
+            "endpoint": "local test",
+            "reflection_model": "fake",
+        },
     )
     original = tune.run_tune
     main_thread = threading.get_ident()

superqode-2.4.6/tests/test_tune_preferences.py

@@ -0,0 +1,38 @@
+"""Tune UI preference persistence across restart."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from superqode.systemone import tune
+
+
+def test_preferred_reflection_model_persists(tmp_path, monkeypatch):
+    path = tmp_path / "tune-preferences.json"
+    monkeypatch.setattr(tune, "tune_preferences_path", lambda: path)
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
+    monkeypatch.delenv("GEMINI_API_KEY", raising=False)
+
+    assert tune.preferred_reflection_model() == ""
+    tune.save_tune_preferences(reflection_lm="gemini/gemini-3.6-flash", max_evals=80)
+    assert path.is_file()
+    assert tune.load_tune_preferences()["reflection_lm"] == "gemini/gemini-3.6-flash"
+    assert tune.preferred_reflection_model() == "gemini/gemini-3.6-flash"
+    tune.save_tune_preferences(reflection_lm="")
+    assert "reflection_lm" not in tune.load_tune_preferences()
+
+
+def test_tuning_support_available_is_bool():
+    from superqode.systemone import tune
+
+    assert isinstance(tune.tuning_support_available(), bool)
+
+
+def test_refresh_tuning_support_import_returns_bool(monkeypatch):
+    from superqode.systemone import tune
+
+    monkeypatch.setattr(tune, "tuning_support_available", lambda: True)
+    # refresh still runs importlib path; just ensure it returns bool when available monkeypatched mid-call is hard —
+    # call the real function: should not raise
+    assert isinstance(tune.refresh_tuning_support_import(), bool)