Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.
C++
launch: a run by flags reuses the tuning result stored for the same model, choices and computer and says so; --retune measures again
Niko1221ee8e6404b017
diff --git a/docs/TERMINAL_LAUNCH.md b/docs/TERMINAL_LAUNCH.mdindex 805497291..23444e1d1 100644--- a/docs/TERMINAL_LAUNCH.md+++ b/docs/TERMINAL_LAUNCH.md@@ -70,7 +70,7 @@ strata launch --list-presets | --delete-preset NAME | --status | --stop [--prese`strata launch --help` lists everything with examples. An unknown model or flag gets a plain message with the closest match. Presets are small files in `launch-presets/` beside the profilesfolder; the run uses the shared profile `launch-<name>` and the shared tuning presets (`strata presets`), so the app sees them too. Flags next to `--preset` change that start only-(add `--save-preset` to keep them).+(add `--save-preset` to keep them). `--plan` shows the model (also for your own files, which it recognises), the context, the picture setting and what would be downloaded and how big (0 when everything is already here). A model that was tuned before for the same choices on the same computer is not measured again by `--tune quick`; the stored result is used and the run says so. Add `--retune` to measure again.## Connect your apps: `strata connect`diff --git a/strata_cli/launch/app.py b/strata_cli/launch/app.pyindex b0a8500a4..8a327b95a 100644--- a/strata_cli/launch/app.py+++ b/strata_cli/launch/app.py@@ -43,6 +43,7 @@ class Ctx:glyphs: Glyphs = field(default_factory=Glyphs)feed: str | None = Nonemove_data: bool = False+ retune: bool = Falsenotes: list[str] = field(default_factory=list)start_own_files: bool = Falsepicked_in_list: bool = False@@ -263,7 +264,7 @@ class LaunchApp(App):s = self.ctx.settingsself.cancel = threading.Event()self.runner = Runner(s, catalog=self.ctx.catalog, emit=self._emit, cancel=self.cancel, feed=self.ctx.feed, confirm=self._ask_from_run,- move_data=self.ctx.move_data)+ move_data=self.ctx.move_data, retune=self.ctx.retune)gb = getattr(self.runner, "download_gb", lambda: 0.0)() if not confirmed else 0.0if gb >= 1.0:free = self.ctx.catalog.disk_free(s.data_dir or self.ctx.catalog.data_dir())@@ -404,7 +405,7 @@ def run_monitor(info: dict, *, keep_default: bool = True, color: str = "auto") -def run_tui(settings: S.LaunchSettings | None, *, catalog: Catalog | None = None, feed: str | None = None, auto_run: bool = False,- save: bool = False, open_page: bool = False, move_data: bool = False) -> int:+ save: bool = False, open_page: bool = False, move_data: bool = False, retune: bool = False) -> int:"""Open the launch screens. `settings` given and `auto_run`: skip the questions and go straight to the run."""catalog = catalog or Catalog()print("Looking at this computer…", flush=True)@@ -419,7 +420,7 @@ def run_tui(settings: S.LaunchSettings | None, *, catalog: Catalog | None = Nones.name = f"{s.model or 'model'} {S.context_label(s.context)}"if save:store.save(s, s.name)- ctx = Ctx(catalog=catalog, computer=computer, rows=rows, settings=s, glyphs=Glyphs(), feed=feed, move_data=move_data)+ ctx = Ctx(catalog=catalog, computer=computer, rows=rows, settings=s, glyphs=Glyphs(), feed=feed, move_data=move_data, retune=retune)app = LaunchApp(ctx, auto_run=auto_run)result = app.run()if getattr(app, "return_code", 0) not in (0, None) or getattr(app, "_exception", None) is not None:diff --git a/strata_cli/launch/cmd.py b/strata_cli/launch/cmd.pyindex 477d43b9c..62807cf79 100644--- a/strata_cli/launch/cmd.py+++ b/strata_cli/launch/cmd.py@@ -113,6 +113,9 @@ def add_parsers(sp: argparse._SubParsersAction) -> list[argparse.ArgumentParser]a.add_argument("--no-api-key", action="store_true", help="share beyond this computer without an API key (a warning is shown, nothing is refused)")o = p.add_argument_group("running")o.add_argument("--save-preset", metavar="NAME", help="save these choices under this name")+ o.add_argument("--retune", action="store_true",+ help="with --tune (quick is used when --tune is not given): measure again even when this model was already tuned on this computer "+ "(by default a stored tuning result is reused and no measuring is done)")o.add_argument("--no-tui", action="store_true", help="no screens: serve, print the address and return")o.add_argument("--open", action="store_true", help="open the server's web page in your browser once it is serving (nothing opens a browser without this)")o.add_argument("--yes", action="store_true", help="do not ask questions (for one: whether to download the model on a computer with no engine yet)")@@ -562,7 +565,10 @@ def run_launch(a: argparse.Namespace) -> int:return _tui(app.run_tui, None, catalog=catalog, feed=a.feed, open_page=bool(a.open))if catalog is None:return fail("This Terminal does not carry the model list. Install it again with the one-line installer.", 5)- runner = Runner(s, catalog=catalog, emit=_printer(machine), feed=a.feed, assume_yes=bool(a.yes or machine), confirm=_ask_yes)+ if getattr(a, "retune", False) and s.tune == "skip":+ s.tune = "quick"+ runner = Runner(s, catalog=catalog, emit=_printer(machine), feed=a.feed, assume_yes=bool(a.yes or machine), confirm=_ask_yes,+ retune=bool(getattr(a, "retune", False)))try:runner.check_own_files() # the person's own files: a wrong path is said now, and the files name the modelexcept LaunchError as e:@@ -618,7 +624,7 @@ def run_launch(a: argparse.Namespace) -> int:if interactive and have_choices:from strata_cli.launch import appreturn _tui(app.run_tui, s, catalog=catalog, feed=a.feed, auto_run=True, save=bool(a.save_preset), open_page=bool(a.open),- move_data=move_data)+ move_data=move_data, retune=bool(getattr(a, "retune", False)))try:result = runner.run()except LaunchError as e:diff --git a/strata_cli/launch/runner.py b/strata_cli/launch/runner.pyindex c51f09673..078ccc9fb 100644--- a/strata_cli/launch/runner.py+++ b/strata_cli/launch/runner.py@@ -323,8 +323,10 @@ class Runner:def __init__(self, s: S.LaunchSettings, *, catalog: Catalog | None = None, emit: Callable[[Event], None] | None = None,cancel: threading.Event | None = None, feed: str | None = None, python: str | None = None,components_dir: str | None = None, hardware: dict | None = None,- confirm: Callable[[str, str], bool] | None = None, assume_yes: bool = False, move_data: bool = False):+ confirm: Callable[[str, str], bool] | None = None, assume_yes: bool = False, move_data: bool = False,+ retune: bool = False):self.s = s+ self.retune = retune # --retune: measure again even when a tuning result for this model on this computer is storedself.move_data = move_data # --move-data / the answer "move": the model files already here go to the new --data-dirself.confirm = confirm # asked (title, text) before a model is downloaded with no engine; True = go onself.assume_yes = assume_yes # --yes: no questions@@ -890,16 +892,23 @@ class Runner:if s.tune == "skip":returnfrom strata_control import presets- if s.tuned_preset:- try:- presets.find(s.tuned_preset)- self.emit("tune", "This preset is already tuned for this computer.", 100)+ if not self.retune:+ if s.tuned_preset:+ try:+ presets.find(s.tuned_preset)+ self.emit("tune", "This preset is already tuned for this computer.", 100)+ return+ except presets.PresetError:+ pass+ elif s.tuned_at: # measured before: the standard settings were already the fastest, nothing was saved+ self.emit("tune", f"Already tuned on {s.tuned_at}: this computer runs best with the standard settings. Nothing to do.", 100)+ return+ stored = self.stored_tuning()+ if stored: # the same model and choices were tuned on this computer before (a run by flags, no preset)+ s.tuned_preset, s.tuned_at = stored["id"], stored["date"]+ self.emit("tune", f"This model was already tuned for this computer on {stored['date']} ('{stored['name']}'), so that result is used "+ "and nothing is measured again. Add --retune to measure again.", 100)return- except presets.PresetError:- pass- elif s.tuned_at: # measured before: the standard settings were already the fastest, nothing was saved- self.emit("tune", f"Already tuned on {s.tuned_at}: this computer runs best with the standard settings. Nothing to do.", 100)- returnmode = "thorough" if s.tune == "thorough" else "quick"status_file = launch_dir() / f"{self.name}.tune.json"try:@@ -945,6 +954,22 @@ class Runner:s.tuned_at = time.strftime("%Y-%m-%d")self.emit("tune", f"Tuning result: {word}. {sentence}", 100, level="info" if word in ("faster", "already fastest") else "warn", word=word)+ def stored_tuning(self) -> dict | None:+ """The tuning result stored for this launch's model, choices and computer (the active preset of its slot in the shared presets store,+ which the start applies), or None. A result whose computer changed in a way that matters (a different card, processor or memory,+ another model file) is not reused: it is measured again."""+ if self.config_path is None:+ return None+ from strata_control import presets+ try:+ _cfg, info = presets.overlay(read_config(self.config_path))+ if not info.get("applied") or not info.get("preset"):+ return None+ made = str(presets.load(info["preset"]["id"]).get("created") or "")[:10]+ return {"id": info["preset"]["id"], "name": info["preset"]["name"], "date": made or time.strftime("%Y-%m-%d")}+ except Exception: # noqa: BLE001 - an unreadable store means: measure+ return None+tune_word: str | None = None# ---- 5. startdiff --git a/tests/terminal/test_flow2_022.py b/tests/terminal/test_flow2_022.pyindex 2cd8c38f4..5a6d2f314 100644--- a/tests/terminal/test_flow2_022.py+++ b/tests/terminal/test_flow2_022.py@@ -301,5 +301,87 @@ class QuietStep(Base):+class StoredTuning(Base):+ """Finding 6: a run by flags (no saved preset) reuses the tuning result stored for the same model, choices and computer."""++ IDENT = {"hardware": {"hard": {"gpus": ["RTX 5070"], "cpu": "test", "logical": 16, "ram_gib": 64}, "soft": {}},+ "engine": {"backend": "cuda"}, "model": {"sha256_shard1": "abc"}}++ def setUp(self):+ super().setUp()+ from strata_control import presets+ self.presets = presets+ self.cfg_path = self.base / "launch.json"+ self.cfg = {"args": ["--native", "x/model-00001-of-00002.gguf", "--max-context", "32768", "--kv", "int8"], "model_name": "qwen"}+ self.cfg_path.write_text(json.dumps(self.cfg), encoding="utf-8")+ self.ident = json.loads(json.dumps(self.IDENT))+ p = mock.patch.object(presets, "current_identity", lambda cfg, **kw: self.ident)+ p.start()+ self.addCleanup(p.stop)++ def store(self):+ return self.presets.create({"settings": {"args": {}, "env": {}, "per_request": {}}, "outcome": "improved"},+ choices=self.presets.choices_from_config(self.cfg), identity=self.ident, name="Q2 32K - Full speed")++ def runner_for_tune(self, retune=False):+ r = self.runner(family="qwen", model="Q2_0", tune="quick")+ r.retune = retune+ r.config_path = self.cfg_path+ return r++ def run_tune(self, r):+ seen = []+ r.emit_cb = lambda ev: seen.append(ev.text)+ with mock.patch.object(Runner, "_spawn", side_effect=RuntimeError("the tuner started")) as spawn:+ try:+ r.tune()+ started = False+ except RuntimeError:+ started = True+ return seen, started++ def test_nothing_stored_means_it_is_measured(self):+ seen, started = self.run_tune(self.runner_for_tune())+ self.assertTrue(started)++ def test_a_stored_result_is_used_and_said(self):+ saved = self.store()+ r = self.runner_for_tune()+ seen, started = self.run_tune(r)+ self.assertFalse(started)+ text = seen[-1]+ self.assertIn("already tuned for this computer", text)+ self.assertIn("Q2 32K - Full speed", text)+ self.assertIn("--retune", text)+ self.assertEqual(r.s.tuned_preset, saved["id"])+ self.assertTrue(r.s.is_tuned)++ def test_retune_measures_again(self):+ self.store()+ seen, started = self.run_tune(self.runner_for_tune(retune=True))+ self.assertTrue(started)++ def test_another_context_is_another_result(self):+ self.store()+ self.cfg["args"][3] = "65536"+ self.cfg_path.write_text(json.dumps(self.cfg), encoding="utf-8")+ seen, started = self.run_tune(self.runner_for_tune())+ self.assertTrue(started)++ def test_a_changed_graphics_card_is_measured_again(self):+ self.store()+ self.ident["hardware"]["hard"]["gpus"] = ["RTX 4090"]+ seen, started = self.run_tune(self.runner_for_tune())+ self.assertTrue(started)++ def test_the_flag_asks_for_a_new_measurement_and_implies_quick(self):+ code, out, err = run_cli(["launch", "--plan", "--output", "json", "--model", "q2_0", "--retune"])+ self.assertEqual(code, 0, err)+ self.assertEqual(json.loads(out)["plan"]["settings"]["tune"], "quick")+ code, out, err = run_cli(["launch", "--help"])+ self.assertIn("--retune", out)+++if __name__ == "__main__":unittest.main()