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++
Owner round 8: show the real engine error, keep cards and roles, honour --mtp off, plan every download, check the engine version
Niko1221c67180edf1bf
diff --git a/setup.py b/setup.pyindex 8358380b9..bf800d3c3 100644--- a/setup.py+++ b/setup.py@@ -7429,7 +7429,7 @@ def install_own_path(a, family, gpu, hip, amd, cuda_tk, multi, port, ram, adoptepart = gguf.with_name(gguf.name + ".part")left = 0 if gguf.exists() and done(gguf) else (size - (part.stat().st_size if part.is_file() else 0)) / 1e9if left and free_gb(folder) < left:- fail(f"not enough free disk space in {folder}: need ~{left:.0f} GB, {free_gb(folder):.0f} GB free", "use --models-dir on a bigger drive")+ fail(f"not enough free disk space in {folder}: need ~{left:.0f} GB, {free_gb(folder):.0f} GB free", ("use --data-dir on a bigger drive (strata launch --data-dir)" if CONTROL else "use --models-dir on a bigger drive"))if left and free_gb(folder) < left + 1:warn(f"little free disk space in {folder}: {free_gb(folder):.1f} GB free for about {left:.1f} GB. Setup goes on and should fit")@@ -7576,7 +7576,7 @@ def preview_family(a) -> int:if f.with_name(f.name + ".part").is_file() else 0)for f in files if not (f.exists() and done(f))) / 1e9if left and free_gb(folder) < left:- fail(f"not enough free disk space in {folder}: need ~{left:.0f} GB, {free_gb(folder):.0f} GB free", "use --models-dir on a bigger drive")+ fail(f"not enough free disk space in {folder}: need ~{left:.0f} GB, {free_gb(folder):.0f} GB free", ("use --data-dir on a bigger drive (strata launch --data-dir)" if CONTROL else "use --models-dir on a bigger drive"))if left and free_gb(folder) < left + 1:warn(f"little free disk space in {folder}: {free_gb(folder):.1f} GB free for about {left:.1f} GB. Setup goes on and should fit")step(5, f"downloading {fam['title']} {model}")@@ -7752,6 +7752,9 @@ def mac_control_setup(a) -> int:ok("the experts stream from the SSD: no MTP draft layer (one token per step is faster there)")elif stream:ok(f"the experts stream from the SSD; the MTP draft layer stays on, with --spec {MF.STREAM_SPEC}")+ if use_mtp and a.mtp == "off" and not (mtp / "mtp-q2_0.gguf").exists():+ ok("the draft layer (MTP) is off: its ~5 GB are not downloaded (`--mtp on` fetches it later)") # round 8, N3+ use_mtp = Falseif use_mtp and not (mtp / "mtp-q2_0.gguf").exists():say(" The MTP draft layer (speculative decoding) comes from the original Qwen checkpoint: only its ~5 GB of MTP tensors are downloaded.")fetch_mtp(mtp, env)@@ -8609,7 +8612,7 @@ def main() -> int:if free_now < real:fail(f"not enough free disk space in {models_dir}: need ~{real:.0f} GB, {free_now:.0f} GB free" +(f" ({on_disk:.0f} GB of the model is already there)" if on_disk >= 1 and not have_model else ""),- "use --models-dir on a bigger drive")+ ("use --data-dir on a bigger drive (strata launch --data-dir)" if CONTROL else "use --models-dir on a bigger drive"))if free_now < need:warn(f"little free disk space in {models_dir}: {free_now:.0f} GB free for about {real:.0f} GB of files. ""Setup goes on and should fit; free up space if it stops")@@ -8740,7 +8743,9 @@ def main() -> int:if corrupt:warn("some MTP tensors are not the checkpoint's (a download mirror that ignored range requests, #327): ""fetching them again and rebuilding the draft layer")- if corrupt or not (rt / "experts.bin").exists():+ if a.mtp == "off" and not (rt / "experts.bin").exists():+ ok("the draft layer (MTP) is off: its ~5 GB are not downloaded (`--mtp on` fetches it later)") # round 8, N3+ elif corrupt or not (rt / "experts.bin").exists():say(" The MTP draft layer (speculative decoding, ~2x faster output) comes from the original Qwen checkpoint:")say(" only its ~5 GB of MTP tensors are downloaded.")fetch_mtp(mtp, env)@@ -8750,8 +8755,9 @@ def main() -> int:env=env)# a setup run again without --draft-vocab keeps the subset this model's config chose before (cyrillic, fr, en)draft_vocab = a.draft_vocab or saved_draft_vocab(home() / f"strata-{tag.lower()}.json")- refresh_draft_vocab(rt, draft_vocab or "cjk")- ok(f"MTP draft layer: {rt}")+ if (rt / "experts.bin").exists():+ refresh_draft_vocab(rt, draft_vocab or "cjk")+ ok(f"MTP draft layer: {rt}")for line in draft_vocab_note(gpu.get("vram_gb", 0.0), draft_vocab): # #474: a recommendation, nothing changessay(" " + line)diff --git a/strata_cli/launch/adopt.py b/strata_cli/launch/adopt.pyindex 83529fe2d..8c01a3c74 100644--- a/strata_cli/launch/adopt.py+++ b/strata_cli/launch/adopt.py@@ -5,7 +5,7 @@ that this Terminal does not run. When setup says it cannot set this card up, andprepared before, "use model files I already have"), the run config is simple enough to write here: the same arguments setup writes for the GSQ-RCO models,with the engine named as the component (`component:strata-engine`). Nothing is downloaded, prepared or compiled; if a file is missing the person is told which.-Only the GSQ-RCO families (qwen, swift, coder) are adopted this way; images stay off.+Only the GSQ-RCO families (qwen, swift, coder) and Gyro (one GGUF with its n-gram table inside) are adopted this way; images stay off."""from __future__ import annotations@@ -15,7 +15,7 @@ import refrom pathlib import PathSHARD = re.compile(r"^(?P<stem>.+)-(?P<i>\d{5})-of-(?P<n>\d{5})\.gguf$")-FAMILIES = ("qwen", "swift", "coder")+FAMILIES = ("qwen", "swift", "coder", "gyro") # the catalog offers Gyro-S / Gyro-M on an Arc card too (round 8, N11)UNSUPPORTED = ("no nvidia gpu found", "no amd gpu", "nvidia gpu", "not supported", "cannot be used")@@ -52,16 +52,25 @@ def find_shards(folder: Path) -> list[Path]:return []+def find_single(folder: Path) -> list[Path]:+ """The one model file of a Gyro folder (a single GGUF, not a picture reader); [] when there is none or several."""+ files = [p for p in sorted(Path(folder).glob("*.gguf")) if not p.name.lower().startswith("mmproj")]+ return files if len(files) == 1 else []++def plan(*, family: str, model: str, model_dir: Path, data_dir: Path, src: Path, context: int, kv: str | None, model_name: str, family_def: dict,- log: Path, backend: str | None, vram_gb: float = 0.0, notes: list | None = None) -> tuple[dict | None, list[str]]:- """(config, problems): the config to write, or None with plain-words problems (what is missing)."""+ log: Path, backend: str | None, vram_gb: float = 0.0, notes: list | None = None, pack_name: str | None = None) -> tuple[dict | None, list[str]]:+ """(config, problems): the config to write, or None with plain-words problems (what is missing). `pack_name`: the pack folder under+ packs/ (default the model's name in lower case; Gyro's is its tag, gyro-gyro-s)."""problems: list[str] = []if family not in FAMILIES:- return None, [f"Strata can write the settings itself only for the Qwen3.8-Flash-Next, Swift and Coder files, not for {family}."]- shards = find_shards(model_dir)+ # no full stop: the caller joins the problems with "; " and ends the sentence (a "gyro.." came out of the old text, round 8, N11)+ return None, [f"Strata can write the settings itself only for the Qwen3.8-Flash-Next, Swift, Coder and Gyro files, not for {family}"]+ shards = find_single(model_dir) if family == "gyro" else find_shards(model_dir)if not shards:- problems.append(f"the model files are not all in {model_dir} (every -0000N-of-0000N.gguf shard is needed)")- pack = Path(data_dir) / "packs" / model.lower()+ problems.append(f"the model file is not in {model_dir}" if family == "gyro" else+ f"the model files are not all in {model_dir} (every -0000N-of-0000N.gguf shard is needed)")+ pack = Path(data_dir) / "packs" / (pack_name or model.lower())if not (pack / "experts.bin").exists() and not (pack / "index.txt").exists():problems.append(f"the prepared pack {pack} is missing (this installer cannot prepare it for this graphics card)")tokenizer = pack / "tokenizer"@@ -74,7 +83,7 @@ def plan(*, family: str, model: str, model_dir: Path, data_dir: Path, src: Path,return None, problemsmtp = Path(data_dir) / "mtp" / "rt"args = ["--pack", str(pack), "--native", str(shards[0])]- if len(shards) > 1:+ if len(shards) > 1 or family == "gyro": # Gyro's one file holds the n-gram table tooargs += ["--ple-gguf", str(shards[-1])]if backend == "metal":# a Mac: the Metal defaults metal/setup_mac.py writes for a model that streams from the SSD (one token per step, no draft layer, the GGUF mapped in place)diff --git a/strata_cli/launch/cmd.py b/strata_cli/launch/cmd.pyindex 18e88b68a..fd3f5c94e 100644--- a/strata_cli/launch/cmd.py+++ b/strata_cli/launch/cmd.py@@ -465,7 +465,15 @@ def _move_data_choice(a: argparse.Namespace, s: S.LaunchSettings, catalog, machigb = library.movable_library(catalog.data_dir(), Path(a.data_dir).expanduser())except Exception: # noqa: BLE001 - no answer to "where are my models": nothing to ask aboutreturn False- return library.ask_move(gb, Path(a.data_dir).expanduser()) if gb > 0 else False+ if gb <= 0:+ return False+ new = Path(a.data_dir).expanduser()+ if getattr(a, "no_tui", False) or not sys.stdin.isatty():+ # --no-tui and a run without a keyboard never ask (round 8, M): the default that loses nothing, said out loud+ size = f"{gb:.0f} GB" if gb >= 10 else f"{gb:.1f} GB"+ _say(f"Keeping your {size} of models where they are; {new} is used for new downloads. (--move-data moves them instead.)")+ return False+ return library.ask_move(gb, new)def open_page(url: str) -> bool:@@ -615,8 +623,8 @@ def run_launch(a: argparse.Namespace) -> int:interactive = sys.stdin.isatty() and sys.stdout.isatty() and not a.no_tui and not machine and not a.planplain_questions = Falseif not have_choices and not interactive and not a.plan:- if machine or catalog is None or not _can_ask():- return fail("`strata launch` with no choices opens screens, and this is not a terminal. Name what to start: --preset NAME, or --model NAME "+ if machine or a.no_tui or catalog is None or not _can_ask(): # --no-tui never asks (round 8, M)+ return fail("`strata launch` with no choices opens screens, and this is not a terminal (or --no-tui was given). Name what to start: --preset NAME, or --model NAME ""(strata launch --help has examples; --plan shows what would happen without changing anything).", 2)# Git Bash, mintty and some editor panels cannot show the screens although a person is typing: go on in plain lines, and ask firstplain_questions = Truediff --git a/strata_cli/launch/modelstate.py b/strata_cli/launch/modelstate.pyindex fc4729daa..1afd01b71 100644--- a/strata_cli/launch/modelstate.py+++ b/strata_cli/launch/modelstate.py@@ -91,7 +91,8 @@ def mmproj_name(catalog, family: str | None) -> str:def assess(catalog, family: str | None, model: str | None, *, vision: str = "off", model_path: str | None = None,- data_dir: str | Path | None = None, config: Path | None = None, desc: dict | None = None, rows: list | None = None) -> ModelState:+ data_dir: str | Path | None = None, config: Path | None = None, desc: dict | None = None, rows: list | None = None,+ mtp: str | None = None) -> ModelState:"""The state of `family model` for these choices. `config` / `desc` are the installed run config and its description (looked up whennot given)."""st = ModelState()@@ -104,7 +105,7 @@ def assess(catalog, family: str | None, model: str | None, *, vision: str = "offfirst = _first_gguf(Path(model_path))beside = discovery.prepared_beside(first) if first else {}st.folder = beside.get("data_dir")- if beside.get("pack") is not None and beside.get("mtp") is None:+ if beside.get("pack") is not None and beside.get("mtp") is None and mtp != "off":st.parts.append(Part("mtp", "the draft layer", MTP_FETCH_GB))if wants_pictures and beside.get("pack") is not None and not beside.get("mmproj"):st.parts.append(Part("mmproj", "the picture reader", MMPROJ_GB))@@ -128,7 +129,7 @@ def assess(catalog, family: str | None, model: str | None, *, vision: str = "offst.parts.append(Part("weights", "the model", max(st.total_gb, 0.0)))return stfor m in fp.missing():- if m.kind == "mtp":+ if m.kind == "mtp" and mtp != "off":st.parts.append(Part("mtp", "the draft layer", MTP_FETCH_GB))elif m.kind == "mmproj" and wants_pictures:st.parts.append(Part("mmproj", "the picture reader", MMPROJ_GB))diff --git a/strata_cli/launch/runner.py b/strata_cli/launch/runner.pyindex 9df6ce552..9d0903c99 100644--- a/strata_cli/launch/runner.py+++ b/strata_cli/launch/runner.py@@ -34,6 +34,31 @@ ROOT = Path(__file__).resolve().parents[2]WINDOWS = os.name == "nt"+def install_isolation_words(catalog, data_dir: str | os.PathLike | None = None) -> list[str]:+ """Round 8, N5: a clean test (a scratch data folder) silently ran an OLDER install found elsewhere (its run config and engine 0.1.41).+ When a data folder was chosen (--data-dir, or STRATA_DATA_DIR from the installer) and the install in use is outside it, say which one is used+ and why. Nothing is moved or switched."""+ chosen = data_dir or os.environ.get("STRATA_DATA_DIR")+ places = getattr(catalog, "places", None) or []+ if not chosen or not places or places[0].source == "explicit":+ return []+ main = Path(places[0].path)+ try:+ inside = os.path.commonpath([os.path.abspath(main), os.path.abspath(chosen)]) == os.path.abspath(chosen)+ except ValueError:+ inside = False+ if inside:+ return []+ return [f"Strata is using the earlier install in {main} ({places[0].configs} saved model setting(s) and its engine settings), not a clean one in "+ f"{chosen}: the data folder only says where model files are kept. To test from scratch, use a new user account or remove the earlier install first."]+++def version_tuple(version: str | None) -> tuple[int, ...]:+ """'0.1.45.3' -> (0, 1, 45, 3); () when it is not a dotted run of numbers (a source build says so itself)."""+ m = re.match(r"\d+(?:\.\d+)*", str(version or "").strip())+ return tuple(int(x) for x in m.group(0).split(".")) if m else ()++def python_failure(lines: list[str]) -> str | None:"""The last line of a Python traceback in setup.py's output (ModuleNotFoundError: No module named 'calibrate'), or None when theoutput holds no traceback. Frames are skipped; the exception line is the first unindented line after the last 'Traceback'."""@@ -418,6 +443,7 @@ class Runner:self.hardware_override = hardwareself.children: list[subprocess.Popen] = []self.notices: list[str] = []+ self.identity_notes: list[str] = []self.tune_result: dict | None = Noneself.config_path: Path | None = Noneself._own_checked = False@@ -483,12 +509,18 @@ class Runner:from strata_control import engine_component as ecroot = Path(self.components_dir) if self.components_dir else Nonereport = ec.status(root)+ stale = Noneif report.get("usable"):eng = report["engine"]- self.emit("engine", f"Engine {eng['version']} ({eng['backend']}) is installed.", 100)- return+ stale = self.stale_engine(eng.get("version"))+ if not stale:+ self.emit("engine", f"Engine {eng['version']} ({eng['backend']}) is installed.", 100)+ returnfeed = self.feed or os.environ.get("STRATA_UPDATE_FEED")- self.emit("engine", "No engine is installed yet. Getting the one for your graphics card…", 0)+ if stale:+ self.emit("engine", stale + " Looking for a newer one…", 0, level="warn")+ else:+ self.emit("engine", "No engine is installed yet. Getting the one for your graphics card…", 0)argv = self._cli("update", "--no-control", "--output", "jsonl")if feed:argv += ["--feed", feed]@@ -520,6 +552,19 @@ class Runner:self.emit("engine", str(ev.get("message") or ""))last = evcode = p.wait()+ if stale:+ # an engine is there and was too old: warn, never refuse (round 8, M: 0.1.45.3 was reused although 0.1.47 existed, and Gyro-S failed+ # on kernels only the newer engine has). Whatever the update did, say where it stands.+ after = ec.status(root)+ now = (after.get("engine") or {}).get("version") if after.get("usable") else None+ still = self.stale_engine(now) if now else stale+ if still:+ self.notices.append(still + " Run `strata update`, then start it again.")+ self.emit("engine", still + (" The update did not bring a newer one." if code == 0 else " The update did not finish.") ++ " Run `strata update`, then start it again.", 100, level="warn")+ else:+ self.emit("engine", f"Engine {now} is installed.", 100)+ returnif code == 0:# `strata update` exits 0 when the feed simply has no engine for this PC (or only one for another card family). That is not an# engine: refuse here, before the model (tens of GB) is touched.@@ -541,6 +586,25 @@ class Runner:"Check your internet connection, or point Strata at an update source with --feed, then try again.", 6)self.emit("engine", "The engine is installed.", 100)+ def needed_engine(self) -> tuple[int, ...] | None:+ """The oldest engine this model runs on, from setup.py's own tables (MIN_ENGINE for everything, GYRO_ENGINE for Gyro), or None."""+ try:+ mod = self.catalog.strata.setup_module()+ need = tuple(getattr(mod, "MIN_ENGINE", ()) or ())+ if self.s.family == "gyro":+ need = max(need, tuple(getattr(mod, "GYRO_ENGINE", ()) or ()))+ return need or None+ except Exception: # noqa: BLE001 - no table, no check+ return None++ def stale_engine(self, version: str | None) -> str | None:+ """A plain sentence when the installed engine is older than the model needs, else None."""+ have = version_tuple(version)+ need = self.needed_engine()+ if not have or not need or have >= need:+ return None+ return f"The engine installed here ({version}) is older than this model needs ({'.'.join(map(str, need))} or newer)."+def no_engine(self, reason: str) -> None:"""There is no engine for this computer and none to get. This is a warning, not a refusal: the model may still be downloaded, becausethe engine can be installed afterwards. Ask first (the answer is yes unless the person says no; --yes skips the question) when a@@ -627,6 +691,8 @@ class Runner:args += ["--kv", s.kv]if fam in ("qwen", "coder"):args += ["--experimental-speed-projection", "off"]+ if s.mtp in ("on", "off") and fam in ("qwen", "swift", "coder", "unsloth"):+ args += ["--mtp", s.mtp] # round 8, N3: "--mtp off" never reached setup, which then fetched the 5.2 GB draft layerdata = s.data_dir or self.existing_data_dir()if data:args += ["--data-dir", str(data)]@@ -641,6 +707,8 @@ class Runner:args += ["--gpu-roles", ",".join(f"{k}={v}" for k, v in sorted(s.gpu_roles.items(), key=lambda kv: int(kv[0])))]elif s.gpus:args += ["--gpus", ",".join(str(g) for g in s.gpus)] if len(s.gpus) > 1 else ["--gpu", str(s.gpus[0])]+ else:+ args += self.installed_card_args()if sys.platform == "darwin":# a Mac's setup (Control mode, strata_control/mac_fit.py) takes fewer options (no --kv, --gpu, speed projection)keep = {"--yes", "--no-start", "--family", "--model", "--context", "--vision", "--data-dir", "--gguf-dir", "--move-data",@@ -658,6 +726,25 @@ class Runner:args = outreturn args+ def installed_card_args(self) -> list[str]:+ """--gpu-roles / --gpus of the installed config when the launch names no cards itself. A change of context or pictures runs setup again;+ without these it picked the cards and the Main/Helper roles afresh and reset an explicit choice (round 8, F3: 0=main,1=helper+ came back as 0=helper,1=main). Only a choice that was made ("gpus_asked" / roles) is forwarded, never the automatic pick."""+ try:+ path, _desc = self.installed_state()+ base = read_config(path) if path is not None else None+ if not isinstance(base, dict):+ return []+ roles = base.get("gpu_roles")+ if isinstance(roles, dict) and roles:+ return ["--gpu-roles", ",".join(f"{k}={v}" for k, v in sorted(roles.items(), key=lambda kv: int(kv[0])))]+ cards = installed_cards(base)+ if cards:+ return ["--gpus", ",".join(str(g) for g in cards)] if len(cards) > 1 else ["--gpu", str(cards[0])]+ except Exception: # noqa: BLE001 - never block a launch over remembering the cards+ pass+ return []+def installed_state(self) -> tuple[Path | None, dict | None]:tag = self.catalog.tag_of(self.s.family, self.s.model)path = self.catalog.installed_config(tag)@@ -698,7 +785,7 @@ class Runner:if s.family and s.model and not s.model_path:path, desc = self.installed_state()return modelstate.assess(self.catalog, s.family, s.model, vision=s.vision, model_path=s.model_path, data_dir=s.data_dir,- config=path, desc=desc)+ config=path, desc=desc, mtp=s.mtp)def download_gb(self) -> float:"""How much would be downloaded for this launch right now: 0 when everything is on disk (the model is installed with these choices@@ -887,7 +974,7 @@ class Runner:cfg, problems = adopt.plan(family=s.family, model=s.model, model_dir=model_dir, data_dir=data_dir, src=cat.src,context=s.context or 32768, kv=s.kv, model_name=f"{fam.get('name', s.family)}-{s.model.lower()}", family_def=fam,log=cat.root / f"strata-{tag}.log", backend=backend,- vram_gb=float(cat.computer().main_vram_gb or 0), notes=self.notices)+ vram_gb=float(cat.computer().main_vram_gb or 0), notes=self.notices, pack_name=tag.lower())if cfg is None:raise LaunchError("The installer cannot set up this graphics card yet, and the files Strata would need to write the settings itself are not all there: "+ "; ".join(problems) + ".",@@ -923,6 +1010,14 @@ class Runner:returnraise LaunchError(f"These model files cannot be used: {e}.", "Pick the folder with every shard of one model, or a .gguf file of it.", 5) from Noneif given:+ sel = plan.get("candidate_selection") or {}+ if sel.get("family") and sel.get("model") and (sel["family"], sel["model"]) != (s.family, s.model):+ # round 8, N8: --family swift was accepted for an IQ3_XXS file. The files are not refused (setup takes the named model's files+ # out of the folder by name), but the person is told what the file header says.+ words = (f"These files look like {sel['family']} {sel['model']} (by the file headers), not {s.family} {s.model}. "+ f"Setup will look for {s.family} {s.model} files in that folder and may stop; to use these files, leave out --family and --model.")+ self.identity_notes.append(words)+ self.notices.append(words)hold = [h for h in plan.get("folder_holds") or [] if (h.get("family"), h.get("model")) == (s.family, s.model)]if len(hold) == 1 and hold[0].get("folder"):s.model_path = hold[0]["folder"]@@ -1101,8 +1196,8 @@ class Runner:raise LaunchError(f"The server could not start: {box['e']}", _log_hint(self.config_path), 6)r = box["r"]if not r.get("ok"):- raise LaunchError(f"The server did not become ready ({r.get('state')}: {r.get('error') or r.get('message') or 'see the engine log'}).",- _log_hint(self.config_path), 6)+ text, nxt = explain_engine_exit(r, self.config_path)+ raise LaunchError(text, nxt, 6)self.emit("start", "The model is loaded and answering.", 100)# ---- 6. access@@ -1152,11 +1247,20 @@ class Runner:data = Path(st.folder) if st.folder else (Path(s.data_dir) if s.data_dir else (self.existing_data_dir() or self.catalog.data_dir()))if s.mtp != "off" and "mtp" not in have and not (data / "mtp" / "rt" / "experts.bin").is_file():parts.append({"kind": "mtp", "label": "the draft layer", "gb": MTP_FETCH_GB})- has_reader = list((data / "models").glob("mmproj*.gguf")) or list((data / "Models").glob("mmproj*.gguf"))+ places = [data / "models", data / "Models"]+ if s.model_path: # setup uses a reader that sits with the person's own files (setup.py --gguf-dir)+ own = Path(s.model_path)+ places += [own if own.is_dir() else own.parent, (own if own.is_dir() else own.parent).parent]+ has_reader = any(list(d.glob("mmproj*.gguf")) for d in places if d.is_dir())if wants_pictures and "mmproj" not in have and not has_reader:parts.append({"kind": "mmproj", "label": "the picture reader", "gb": MMPROJ_GB})except OSError:pass+ gap = self.ready_pack_gap() if st.own_files else None+ if gap:+ # a ready-made pack (NVFP4) is taken from setup's own models folder, not from where the person's files are (round 8, N2: the plan+ # said "nothing to download" and setup then asked for 129 GB): count what setup will fetch+ parts = [p for p in parts if p["kind"] != "weights"] + [{"kind": "weights", "label": "the ready-made pack", "gb": gap["gb"]}]gb = round(sum(p["gb"] for p in parts), 1)engine = Truetry:@@ -1174,14 +1278,64 @@ class Runner:text += f" {st.on_disk_gb:.0f} GB of the model is already in its folder."if st.own_files:text += " Your model files are used where they are."+ if gap:+ text += (f" This is a ready-made pack, and setup takes it from its own folder ({gap['folder']}), not from where your files are. "+ "Copy or link your pack there to use it as it is" ++ (f"; only {gap['free_gb']:.0f} GB are free on that drive, so choose a bigger drive with --data-dir" if gap.get("free_gb") is not None and gap["free_gb"] < gap["gb"] else "") + ".")+ if any(p["kind"] == "mmproj" for p in parts):+ text += " To skip the picture reader (the model then answers text only), add --vision off; or put its mmproj file next to your model files."+ if any(p["kind"] == "mtp" for p in parts):+ text += " To skip the draft layer (a little slower, less memory), add --mtp off."if not engine:text += " The engine for your graphics card is downloaded first (from the update source; its size is shown when it starts)."return {"gb": gb, "parts": parts, "engine_missing": not engine, "own_files": st.own_files, "text": text}+ def ready_pack_gap(self) -> dict | None:+ """For a ready-made pack family (NVFP4): what setup would still fetch into its models folder for these choices, {gb, folder, free_gb}, or None."""+ s = self.s+ try:+ mod = self.catalog.strata.setup_module()+ _m, families, _c, _src = self.catalog.tables()+ if mod is None or not (families.get(s.family or "") or {}).get("ready") or not hasattr(mod, "ready_needed"):+ return None+ data = Path(s.data_dir) if s.data_dir else (self.existing_data_dir() or self.catalog.data_dir())+ models_dir = data / "models"+ need = 0+ for f in mod.ready_needed(s.model, models_dir):+ if not mod.ready_verified(mod.ready_where(models_dir, f), f[5]):+ need += int(f[4])+ if need <= 0:+ return None+ probe = next((q for q in (models_dir, *models_dir.parents) if q.exists()), None)+ free = self.catalog.disk_free(probe) if probe is not None else None+ return {"gb": round(need / 1e9, 1), "folder": str(models_dir), "free_gb": free}+ except Exception: # noqa: BLE001 - a plan that cannot work this out still shows the rest+ return None++ def preflight_words(self) -> list[str]:+ """Plain warnings for `--plan` that the run itself would meet: an engine older than the model needs, an earlier install taking the+ place of a clean one, files that are not the model that was named. Nothing is changed."""+ out: list[str] = list(self.identity_notes)+ try:+ from strata_control import engine_component as ec+ report = ec.status(Path(self.components_dir) if self.components_dir else None)+ if report.get("usable"):+ stale = self.stale_engine(report["engine"].get("version"))+ if stale:+ out.append(stale + " Starting will look for a newer one first; `strata update` does the same.")+ except Exception: # noqa: BLE001+ pass+ try:+ out += install_isolation_words(self.catalog, self.s.data_dir)+ except Exception: # noqa: BLE001+ pass+ return out+def plan(self) -> dict:s = self.sself.check_own_files()warns = [n.line() for n in (*S.check_access(s),)]+ warns += self.preflight_words()row = self.row()try:self.resolved_vision()@@ -1248,6 +1402,65 @@ def _read_json(path: Path) -> dict | None:return None+#: lines of an engine log that say why it stopped (the last one wins), and a plain next step for the causes we know. Recommend, never force.+CAUSE_LINE = re.compile(r"error|exception|failed|cannot|can't|could not|no device|not found|out of memory|unsupported|abort|invalid|missing|"+ r"no kernel|illegal|denied|refus", re.I)+KNOWN_CAUSES = (+ (re.compile(r"no device of requested type|device not found|no (gpu|sycl|level.zero) device|permission denied.*(dri|render)", re.I),+ "The engine could not open the graphics card. On Linux the account must be allowed to use it: add it to the render group "+ "(`sudo usermod -aG render $USER`), log in again and start it again."),+ (re.compile(r"out of memory|not enough (gpu |video |free )?memory|cudaerrormemory|allocation failed", re.I),+ "The card or memory ran out. Close other programs that use the card, or choose a smaller context (`--context 16k`) and start again."),+ (re.compile(r"tqk\d|no kernel|unsupported (quant|type|model)|unknown (quant|tensor) type", re.I),+ "This engine is too old for this model. Update it with `strata update` and start again."),+ (re.compile(r"dll|libcu|cannot open shared object|0xc0000135", re.I),+ "A library the engine needs is missing. Update the engine (`strata update`) or install the graphics driver again."),+)+++def engine_log_tail(config: Path | None, limit: int = 65536) -> tuple[list[str], str | None]:+ """(last lines of the engine log, its path); ([], path-or-None) when it cannot be read."""+ log = None+ if config:+ try:+ log = read_config(config).get("log")+ except (OSError, ValueError):+ log = None+ if not log:+ return [], None+ try:+ with open(log, "rb") as stream:+ stream.seek(0, os.SEEK_END)+ stream.seek(max(0, stream.tell() - limit))+ data = stream.read().decode("utf-8", "replace")+ except OSError:+ return [], str(log)+ return [x.rstrip() for x in data.splitlines() if x.strip()], str(log)+++def explain_engine_exit(result: dict, config: Path | None) -> tuple[str, str]:+ """(text, next) for a start that did not reach ready: the stage, the cause line from the engine log, the next step and the log path+ (round 8, L3: an Arc engine died with 'No device of requested type available' and the person saw only 'server_exited')."""+ lines, log = engine_log_tail(config)+ lines = lines or [x.strip() for x in str(result.get("log_tail") or "").split(" | ") if x.strip()]+ cause = next((x for x in reversed(lines) if CAUSE_LINE.search(x) and not x.lstrip().startswith(("strata generate: ", "strata serve: expert"))), None)+ cause = (cause or (lines[-1] if lines else "")).strip()+ cause = re.sub(r"^(\[strata\]\s*)?(\d{4}-\d\d-\d\d[ T][\d:.]+\s*)?", "", cause)[:240]+ state, why = result.get("state"), result.get("error") or result.get("message")+ if why == "startup_wait_expired":+ stage = "The model did not finish loading in time"+ elif why == "server_exited" or result.get("engine_exit_code") is not None:+ code = result.get("engine_exit_code")+ stage = "The engine stopped while it was loading the model" + (f" (exit code {code})" if code not in (None, 0) else "")+ else:+ stage = f"The server did not become ready ({state}: {why or 'see the engine log'})"+ text = stage + (f": {cause}" if cause else ".")+ if not text.endswith((".", "!")):+ text += "."+ step = next((words for pattern, words in KNOWN_CAUSES if pattern.search(" ".join([cause, str(why or "")]))), "Run it again; if it repeats, report the log.")+ return text, step + (f" The engine's log: {log}" if log else " The engine's log has the reason (strata logs, or the log named in the run config).")++def _log_hint(config: Path | None) -> str:log = Noneif config:diff --git a/strata_cli/update_cmd.py b/strata_cli/update_cmd.pyindex 67e89937b..397fc5c38 100644--- a/strata_cli/update_cmd.py+++ b/strata_cli/update_cmd.py@@ -139,6 +139,13 @@ def _print_check(report: dict) -> None:"current": f"{installed} is up to date", "none-for-this-pc": eng.get("note") or "the feed has no engine for this PC","not-in-feed": "the feed lists no engines"}.get(eng["status"], eng.get("note") or eng["status"])print(f" Engine {text}")+ pick = eng.get("offered")+ if pick and eng["status"] in ("available", "install", "current"):+ # round 8, N9: the list below names only the packages that were NOT chosen; say which one was+ label = pick.get("label") or (f"{pick.get('version')} {pick.get('platform')}-{pick.get('backend')}" + (f"-{pick['variant']}" if pick.get("variant") else ""))+ print(f" selected for this PC: {label}")+ if eng.get("reasons"):+ print(" not used for this PC:")for reason in eng.get("reasons") or []:print(f" - {reason}")if eng.get("note") and eng["status"] not in ("failed-before", "skipped", "current"):diff --git a/strata_control/discovery.py b/strata_control/discovery.pyindex 93ac134ce..f919655c8 100644--- a/strata_control/discovery.py+++ b/strata_control/discovery.py@@ -166,6 +166,9 @@ def places(*, here: Path | None = None, explicit: str | os.PathLike | None = Nonp = Path(raw).expanduser()return [Place(p, "explicit", len(config_files(p)))]cands: list[tuple[Path, str]] = []+ data_root = environ.get("STRATA_DATA_DIR")+ if data_root: # the installer's own folder (install.sh / install.ps1): an install kept inside it comes first+ cands.append((Path(data_root).expanduser() / "install", "datadir"))if here is not None:cands.append((Path(here), "here"))own = own_settings_file(environ, windows=windows, home=home)diff --git a/tests/terminal/test_launch.py b/tests/terminal/test_launch.pyindex 8dece84c4..5a3625a1f 100644--- a/tests/terminal/test_launch.py+++ b/tests/terminal/test_launch.py@@ -506,9 +506,10 @@ class AdoptRules(unittest.TestCase):self.assertIsNone(cfg)self.assertTrue(any("prepared pack" in p for p in problems))self.assertTrue(any("tokenizer" in p for p in problems))- cfg, problems = adopt.plan(family="gyro", model="Gyro-S", model_dir=m, data_dir=d, src=Path("."), context=8192, kv=None, model_name="x",+ cfg, problems = adopt.plan(family="unsloth", model="UD-Q4_K_XL", model_dir=m, data_dir=d, src=Path("."), context=8192, kv=None, model_name="x",family_def={}, log=h.base / "x.log", backend=None)self.assertIn("only for the Qwen3.8-Flash-Next", problems[0])+ self.assertNotIn("..", problems[0] + ".") # round 8, N11: the caller adds the full stopdef test_pictures_on_is_setups_yes_and_setup_picks_the_encoder(self):with Home() as h:diff --git a/tests/terminal/test_round8_fixes.py b/tests/terminal/test_round8_fixes.pynew file mode 100644index 000000000..6fac3b9e2--- /dev/null+++ b/tests/terminal/test_round8_fixes.py@@ -0,0 +1,296 @@+"""Owner test round 8 (7 machines), the Control / TUI / setup fixes: F5, F3, N2 to N9, N11."""++import argparse+import io+import json+import os+import sys+import tempfile+import unittest+from contextlib import redirect_stdout+from pathlib import Path+from unittest import mock++from strata_cli.launch import adopt, library, runner as R+from strata_cli.launch import settings as S+from strata_cli.launch.runner import Runner+from tests.terminal.launch_support import HW_12, Home, catalog+++def runner_for(**kw) -> Runner:+ return Runner(S.LaunchSettings(family="qwen", model="IQ3_XXS", context=32768, vision="off", **kw), catalog=catalog(HW_12))+++class EngineExitIsExplained(unittest.TestCase):+ """F5 (L3): an Arc engine died with 'No device of requested type available' and the person saw only 'server_exited'."""++ def config_with_log(self, lines):+ folder = tempfile.TemporaryDirectory()+ self.addCleanup(folder.cleanup)+ log = Path(folder.name) / "engine.log"+ log.write_text("\n".join(lines) + "\n", encoding="utf-8")+ cfg = Path(folder.name) / "run.json"+ cfg.write_text(json.dumps({"log": str(log)}), encoding="utf-8")+ return cfg, log++ def test_arc_without_the_render_group_names_the_cause_the_next_step_and_the_log(self):+ cfg, log = self.config_with_log(["strata generate: memory guard: limit 61.6 GiB", "strata generate: SYCL init",+ "terminate called after throwing an instance of 'sycl::exception'",+ " what(): No device of requested type available. -1 (PI_ERROR_DEVICE_NOT_FOUND)"])+ text, nxt = R.explain_engine_exit({"state": "failed", "error": "server_exited", "engine_exit_code": 134}, cfg)+ self.assertIn("stopped while it was loading the model", text)+ self.assertIn("No device of requested type available", text)+ self.assertNotIn("server_exited", text + nxt)+ self.assertIn("render group", nxt)+ self.assertIn(str(log), nxt)++ def test_out_of_memory_and_old_engine_get_their_own_next_step(self):+ cfg, _ = self.config_with_log(["strata generate: CUDA error: out of memory"])+ self.assertIn("--context 16k", R.explain_engine_exit({"error": "server_exited"}, cfg)[1])+ cfg, _ = self.config_with_log(["strata generate: no kernel for TQK6 on this engine"])+ self.assertIn("strata update", R.explain_engine_exit({"error": "server_exited"}, cfg)[1])++ def test_an_unreadable_log_still_says_the_stage_and_where_to_look(self):+ text, nxt = R.explain_engine_exit({"state": "failed", "error": "server_exited", "log_tail": "boom | Error: cannot map the pack"}, None)+ self.assertIn("cannot map the pack", text)+ self.assertIn("strata logs", nxt)+ text, _ = R.explain_engine_exit({"state": "starting", "error": "startup_wait_expired"}, None)+ self.assertIn("did not finish loading in time", text)+++class NoTuiNeverAsks(unittest.TestCase):+ def test_no_tui_keeps_the_models_and_says_so_without_input(self):+ with tempfile.TemporaryDirectory() as old, tempfile.TemporaryDirectory() as new:+ (Path(old) / "models").mkdir()+ (Path(old) / "models" / "a.gguf").write_bytes(b"x" * 2048)+ from strata_cli.launch import cmd+ a = argparse.Namespace(data_dir=new, move_data=False, yes=False, plan=False, no_tui=True)+ cat = mock.Mock()+ cat.data_dir.return_value = Path(old)+ out = io.StringIO()+ with mock.patch.object(library, "movable_library", return_value=40.0), mock.patch("builtins.input", side_effect=AssertionError("asked")), \+ mock.patch.object(sys, "stdin") as stdin, redirect_stdout(out):+ stdin.isatty.return_value = True+ self.assertFalse(cmd._move_data_choice(a, S.LaunchSettings(), cat, False))+ self.assertIn("Keeping your 40 GB of models where they are", out.getvalue())+ self.assertIn("--move-data", out.getvalue())++ def test_a_run_without_a_keyboard_says_the_same(self):+ from strata_cli.launch import cmd+ a = argparse.Namespace(data_dir="/new", move_data=False, yes=False, plan=False, no_tui=False)+ out = io.StringIO()+ with mock.patch.object(library, "movable_library", return_value=3.0), mock.patch("builtins.input", side_effect=AssertionError("asked")), \+ mock.patch.object(sys, "stdin") as stdin, redirect_stdout(out):+ stdin.isatty.return_value = False+ self.assertFalse(cmd._move_data_choice(a, S.LaunchSettings(), mock.Mock(), False))+ self.assertIn("Keeping your 3.0 GB", out.getvalue())+++class SetupArguments(unittest.TestCase):+ def installed(self, h: Home, **cfg):+ path = h.base / "install" / "strata-iq3_xxs.json"+ path.parent.mkdir(parents=True, exist_ok=True)+ path.write_text(json.dumps({"exe": "x", "args": [], **cfg}), encoding="utf-8")+ return path++ def test_a_context_change_forwards_the_installed_roles(self):+ # F3: 0=main,1=helper came back from a 32k to 16k change as 0=helper,1=main+ with Home() as h:+ path = self.installed(h, gpu=[1, 0], gpus_asked=True, gpu_roles={"0": "main", "1": "helper"})+ r = runner_for()+ with mock.patch.object(Runner, "installed_state", return_value=(path, None)):+ a = r.setup_args()+ self.assertEqual(a[a.index("--gpu-roles") + 1], "0=main,1=helper")++ def test_installed_cards_are_forwarded_and_the_automatic_pick_is_not(self):+ with Home() as h:+ path = self.installed(h, gpu=[1, 0], gpus_asked=True)+ with mock.patch.object(Runner, "installed_state", return_value=(path, None)):+ a = runner_for().setup_args()+ self.assertEqual(a[a.index("--gpus") + 1], "1,0")+ path = self.installed(h, gpu=0) # never asked: setup picks again+ with mock.patch.object(Runner, "installed_state", return_value=(path, None)):+ a = runner_for().setup_args()+ self.assertNotIn("--gpus", a)+ self.assertNotIn("--gpu", a)++ def test_cards_named_on_the_command_line_win_over_the_installed_ones(self):+ with Home() as h:+ path = self.installed(h, gpu=[1, 0], gpus_asked=True, gpu_roles={"0": "main", "1": "helper"})+ with mock.patch.object(Runner, "installed_state", return_value=(path, None)):+ a = runner_for(gpus=[0]).setup_args()+ self.assertEqual(a[a.index("--gpu") + 1], "0")+ self.assertNotIn("--gpu-roles", a)++ def test_mtp_off_reaches_setup(self):+ with Home():+ a = runner_for(mtp="off").setup_args()+ self.assertEqual(a[a.index("--mtp") + 1], "off")+ self.assertNotIn("--mtp", runner_for().setup_args())++ def test_setup_skips_the_draft_layer_download_for_mtp_off(self):+ # setup.py is a script; its two fetch sites must be guarded by the explicit --mtp off (N3: a 5.2 GB download happened anyway)+ text = (Path(__file__).resolve().parents[2] / "setup.py").read_text(encoding="utf-8")+ self.assertIn('if a.mtp == "off" and not (rt / "experts.bin").exists():', text)+ self.assertIn('if use_mtp and a.mtp == "off" and not (mtp / "mtp-q2_0.gguf").exists():', text)+ self.assertIn('"use --data-dir on a bigger drive (strata launch --data-dir)" if CONTROL', text) # N2: a launch option, not --models-dir+++class PlanPredictsEveryDownload(unittest.TestCase):+ def plan_text(self, h: Home, own: Path, **kw) -> dict:+ s = S.LaunchSettings(family="qwen", model="IQ3_XXS", context=32768, vision="on", model_path=str(own), data_dir=str(h.base / "data"), **kw)+ r = Runner(s, catalog=catalog(HW_12))+ with mock.patch.object(Runner, "check_own_files"), mock.patch.object(Runner, "ready_pack_gap", return_value=None):+ return r.download_plan()++ def test_a_local_gguf_without_a_reader_shows_the_picture_reader_and_the_switch(self):+ with Home() as h:+ own = h.base / "own"+ own.mkdir()+ (own / "m-00001-of-00002.gguf").write_bytes(b"x")+ plan = self.plan_text(h, own)+ self.assertIn("picture reader", plan["text"])+ self.assertIn("--vision off", plan["text"])+ self.assertIn("draft layer", plan["text"])+ self.assertIn("--mtp off", plan["text"])++ def test_a_reader_beside_the_files_is_used_and_not_counted(self):+ with Home() as h:+ own = h.base / "own"+ own.mkdir()+ (own / "m-00001-of-00002.gguf").write_bytes(b"x")+ (own / "mmproj-Qwen3.8-Flash-Next-BF16.gguf").write_bytes(b"x")+ plan = self.plan_text(h, own)+ self.assertNotIn("picture reader", plan["text"])++ def test_mtp_off_is_not_counted(self):+ with Home() as h:+ own = h.base / "own"+ own.mkdir()+ (own / "m-00001-of-00002.gguf").write_bytes(b"x")+ self.assertNotIn("draft layer", self.plan_text(h, own, mtp="off")["text"])+++class ReadyPackPlan(unittest.TestCase):+ def test_a_ready_made_pack_is_counted_and_the_hint_is_a_launch_option(self):+ with Home() as h:+ own = h.base / "own"+ own.mkdir()+ r = Runner(S.LaunchSettings(family="qwen", model="IQ3_XXS", context=32768, vision="off", model_path=str(own)), catalog=catalog(HW_12))+ gap = {"gb": 129.0, "folder": str(h.base / "data" / "models"), "free_gb": 110.0}+ with mock.patch.object(Runner, "ready_pack_gap", return_value=gap):+ plan = r.download_plan()+ self.assertGreaterEqual(plan["gb"], 129.0)+ self.assertIn("ready-made pack", plan["text"])+ self.assertIn("--data-dir", plan["text"])+ self.assertNotIn("Nothing to download", plan["text"])+++class EngineIsFreshEnough(unittest.TestCase):+ def test_versions_compare_by_numbers(self):+ self.assertEqual(R.version_tuple("0.1.45.3"), (0, 1, 45, 3))+ self.assertEqual(R.version_tuple("junk"), ())++ def test_an_old_engine_is_named_in_plain_words_and_a_current_one_is_not(self):+ with Home():+ r = runner_for()+ r.catalog.strata.setup_module() # loads setup.py's tables (MIN_ENGINE)+ words = r.stale_engine("0.1.45.3")+ self.assertIn("older than this model needs", words)+ self.assertIn("0.1.45.3", words)+ self.assertIsNone(r.stale_engine("0.1.47"))+ self.assertIsNone(r.stale_engine("source"))++ def test_a_stale_engine_is_updated_or_said_never_ignored(self):+ with Home():+ r = runner_for()+ events = []+ r.emit = lambda stage, text, pct=None, level="info", **kw: events.append((level, text))+ before = {"usable": True, "engine": {"version": "0.1.45.3", "backend": "cuda"}}+ proc = mock.Mock()+ proc.stdout = iter([])+ proc.wait.return_value = 0+ from strata_control import engine_component as ec+ with mock.patch.object(ec, "status", return_value=before), mock.patch.object(Runner, "_spawn", return_value=proc):+ r.ensure_engine()+ self.assertTrue(any(level == "warn" and "older than this model needs" in text for level, text in events), events)+ self.assertTrue(any("strata update" in n for n in r.notices), r.notices)+++class InstallIsNotHijacked(unittest.TestCase):+ def test_an_earlier_install_outside_the_chosen_data_folder_is_named(self):+ with Home() as h:+ cat = mock.Mock()+ cat.places = [mock.Mock(path=h.base / "old" / "Strata", source="app", configs=2)]+ words = R.install_isolation_words(cat, str(h.base / "scratch"))+ self.assertEqual(len(words), 1)+ self.assertIn("earlier install", words[0])+ self.assertIn(str(h.base / "old" / "Strata"), words[0])+ cat.places = [mock.Mock(path=h.base / "scratch" / "install", source="app", configs=1)]+ self.assertEqual(R.install_isolation_words(cat, str(h.base / "scratch")), [])+ cat.places = [mock.Mock(path=h.base / "old", source="explicit", configs=1)]+ self.assertEqual(R.install_isolation_words(cat, str(h.base / "scratch")), [])+ self.assertEqual(R.install_isolation_words(cat, None), [])++ def test_an_install_inside_strata_data_dir_comes_first(self):+ from strata_control import discovery+ with tempfile.TemporaryDirectory() as data, tempfile.TemporaryDirectory() as other:+ for folder in (Path(data) / "install", Path(other) / "install"):+ folder.mkdir()+ (folder / "strata-q.json").write_text("{}", encoding="utf-8")+ env = {"STRATA_DATA_DIR": data}+ found = discovery.places(environ=env, here=Path(other) / "install", home=Path(other))+ self.assertEqual(Path(found[0].path).resolve(), (Path(data) / "install").resolve())+++class IdentityAndAdoption(unittest.TestCase):+ def test_family_that_does_not_match_the_file_header_is_warned_about(self):+ with Home() as h:+ r = Runner(S.LaunchSettings(family="swift", model="IQ2_XS", model_path=str(h.base)), catalog=catalog(HW_12))+ plan = {"candidate_selection": {"family": "qwen", "model": "IQ3_XXS"}, "folder_holds": [], "issues": []}+ from strata_control import models+ with mock.patch.object(models, "own_path_problem", return_value=None), mock.patch.object(models, "plan_import", return_value=plan), \+ mock.patch.object(models, "import_target", return_value=str(h.base)):+ r.resolve_own_files()+ self.assertEqual(len(r.identity_notes), 1)+ self.assertIn("look like qwen IQ3_XXS", r.identity_notes[0])+ self.assertIn("not swift IQ2_XS", r.identity_notes[0])+ self.assertEqual((r.s.family, r.s.model), ("swift", "IQ2_XS")) # warned, never forced++ def test_gyro_is_adopted_like_the_others_and_the_text_has_no_double_period(self):+ with Home() as h:+ data = h.base / "data"+ model_dir = data / "models" / "gyro-Gyro-S"+ model_dir.mkdir(parents=True)+ (model_dir / "Qwen3.8-Flash-Next-Gyro-S-TQ1_0.gguf").write_bytes(b"x")+ pack = data / "packs" / "gyro-gyro-s"+ (pack / "tokenizer").mkdir(parents=True)+ (pack / "index.txt").write_text("x", encoding="utf-8")+ cfg, problems = adopt.plan(family="gyro", model="Gyro-S", model_dir=model_dir, data_dir=data, src=Path(__file__).resolve().parents[2],+ context=8192, kv=None, model_name="gyro", family_def={}, log=h.base / "x.log", backend="sycl",+ pack_name="gyro-gyro-s")+ self.assertEqual(problems, [], problems)+ self.assertEqual(cfg["args"][cfg["args"].index("--ple-gguf") + 1], cfg["args"][cfg["args"].index("--native") + 1])+ _, refused = adopt.plan(family="nvfp4", model="NVFP4", model_dir=model_dir, data_dir=data, src=Path("."), context=8192, kv=None,+ model_name="x", family_def={}, log=h.base / "x.log", backend=None)+ self.assertTrue(refused[0].endswith("not for nvfp4")) # the caller adds the one full stop+++class UpdateCheckNamesTheChoice(unittest.TestCase):+ def test_the_selected_package_is_printed_before_the_rejected_ones(self):+ from strata_cli import update_cmd+ report = {"feed": {"sequence": 107, "channel": "stable", "key_id": "k", "trusted_by": "built-in keys"},+ "engine": {"status": "install", "installed": None, "download_bytes": 5 << 20,+ "offered": {"version": "0.1.47", "platform": "linux-x86_64", "backend": "cuda", "variant": "cuda12"},+ "reasons": ["0.1.47 linux-x86_64-cuda-cuda13 needs driver 580"], "note": None},+ "control": {"status": "current", "installed": "0.1.47", "offered": None}, "app": {"status": "not-in-feed"}}+ out = io.StringIO()+ with redirect_stdout(out):+ update_cmd._print_check(report)+ text = out.getvalue()+ self.assertIn("selected for this PC: 0.1.47 linux-x86_64-cuda-cuda12", text)+ self.assertLess(text.index("selected for this PC"), text.index("not used for this PC"))+++if __name__ == "__main__":+ unittest.main()