zeroquantz 0.1.0__py3-none-any.whl

zeroquantz/tui/screens/model_select.py

@@ -0,0 +1,206 @@
+"""Wizard entry: search for a model and inspect it (metadata only).
+
+As the user types, the Hub is searched live (debounced) and results are shown
+ranked by popularity. Selecting one (↑↓ + Enter, or a mouse click) inspects it
+and advances straight to the quantization step — the model's details are shown
+there, so this screen stays a clean search view.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual import on, work
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Footer, Input, OptionList, Static
+from textual.widgets.option_list import Option
+
+from zeroquantz.agent.intents import Intent, IntentKind
+from zeroquantz.models.search import ModelHit, search_models
+
+_SUGGESTIONS: tuple[tuple[str, str], ...] = (
+    ("Qwen/Qwen3-8B", "8.2B · dense · GQA"),
+    ("Qwen/Qwen2.5-0.5B-Instruct", "0.5B · tiny, fast to inspect"),
+    ("meta-llama/Llama-3.1-8B-Instruct", "8B · gated repo"),
+    ("mistralai/Mistral-7B-Instruct-v0.3", "7B · popular baseline"),
+    ("microsoft/Phi-3.5-mini-instruct", "3.8B · small, strong"),
+)
+
+_DEBOUNCE_SECONDS = 0.35
+_MIN_QUERY = 2
+
+
+class ModelSelectScreen(Screen):
+    BINDINGS = [Binding("escape", "back", "Back")]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="model-page"):
+            yield Static(
+                "Search a model to optimize  ·  ↑↓ to move · Enter or click to load",
+                classes="page-subtitle",
+            )
+            yield Input(placeholder="search models…  e.g. qwen3, llama, phi", id="model-input")
+            yield Static("", id="search-status", classes="page-hint")
+            yield OptionList(id="model-suggestions")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._debounce = None
+        self._pending_query = ""
+        self._suppress_search = False
+        self._loading = False
+        self._show_defaults()
+        self.query_one("#model-input", Input).focus()
+
+    def on_screen_resume(self) -> None:
+        # Returning from the quantization step: clear the transient "inspecting…"
+        # status and restore focus for continued searching.
+        self._loading = False
+        count = self.query_one("#model-suggestions", OptionList).option_count
+        self.query_one("#search-status", Static).update(
+            Text(f"{count} models" if count else "", style="#6e7681")
+        )
+        self.query_one("#model-input", Input).focus()
+
+    # ---- live search --------------------------------------------------------
+
+    @on(Input.Changed, "#model-input")
+    def _changed(self, event: Input.Changed) -> None:
+        if self._suppress_search:
+            self._suppress_search = False
+            return
+        self._pending_query = event.value.strip()
+        if self._debounce is not None:
+            self._debounce.stop()
+        self._debounce = self.set_timer(_DEBOUNCE_SECONDS, self._fire_search)
+
+    def _fire_search(self) -> None:
+        query = self._pending_query
+        if len(query) < _MIN_QUERY:
+            self._show_defaults()
+            return
+        self.query_one("#search-status", Static).update(Text(f"searching “{query}” …", style="#d29922"))
+        self._search(query)
+
+    @work(thread=True, exclusive=True, group="model-search")
+    def _search(self, query: str) -> None:
+        try:
+            hits: list[ModelHit] | None = search_models(query, limit=20)
+        except Exception:
+            hits = None
+        self.app.call_from_thread(self._populate, query, hits)
+
+    def _populate(self, query: str, hits: list[ModelHit] | None) -> None:
+        if self.query_one("#model-input", Input).value.strip() != query:
+            return
+        options = self.query_one("#model-suggestions", OptionList)
+        status = self.query_one("#search-status", Static)
+        if hits is None:
+            status.update(Text("offline — showing common models", style="#d29922"))
+            self._show_defaults()
+            return
+        if not hits:
+            status.update(Text("no matching models", style="#6e7681"))
+            options.clear_options()
+            return
+        status.update(Text(f"{len(hits)} models — most downloaded first", style="#6e7681"))
+        options.clear_options()
+        for hit in hits:
+            text = Text()
+            text.append("● ", style="#3fb950")
+            text.append(hit.id, style="bold #58a6ff")
+            meta = hit.meta_line()
+            if meta:
+                text.append(f"   {meta}", style="#6e7681")
+            options.add_option(Option(text, id=hit.id))
+
+    def _show_defaults(self) -> None:
+        options = self.query_one("#model-suggestions", OptionList)
+        options.clear_options()
+        for model_id, note in _SUGGESTIONS:
+            text = Text()
+            text.append("● ", style="#3fb950")
+            text.append(model_id, style="bold #58a6ff")
+            text.append(f"   {note}", style="#6e7681")
+            options.add_option(Option(text, id=model_id))
+
+    # ---- navigation & selection --------------------------------------------
+
+    def on_key(self, event) -> None:  # noqa: ANN001
+        """Drive the results list with ↑/↓ while the search box keeps focus."""
+        if self._loading:
+            return
+        if not self.query_one("#model-input", Input).has_focus:
+            return
+        if event.key == "down":
+            self._move_highlight(1)
+            event.stop()
+            event.prevent_default()
+        elif event.key == "up":
+            self._move_highlight(-1)
+            event.stop()
+            event.prevent_default()
+
+    def _move_highlight(self, delta: int) -> None:
+        options = self.query_one("#model-suggestions", OptionList)
+        count = options.option_count
+        if count == 0:
+            return
+        current = options.highlighted
+        nxt = 0 if current is None else max(0, min(count - 1, current + delta))
+        options.highlighted = nxt
+        try:
+            options.scroll_to_highlight()
+        except Exception:
+            pass
+
+    @on(Input.Submitted, "#model-input")
+    def _submit(self, event: Input.Submitted) -> None:
+        options = self.query_one("#model-suggestions", OptionList)
+        model_id: str | None = None
+        if options.highlighted is not None and options.option_count:
+            model_id = str(options.get_option_at_index(options.highlighted).id)
+        if not model_id:
+            model_id = event.value.strip()
+        if model_id:
+            self._load(model_id)
+
+    @on(OptionList.OptionSelected, "#model-suggestions")
+    def _pick(self, event: OptionList.OptionSelected) -> None:
+        model_id = str(event.option.id)
+        self._suppress_search = True
+        self.query_one("#model-input", Input).value = model_id
+        if self._debounce is not None:
+            self._debounce.stop()
+        self._load(model_id)
+
+    # ---- loading ------------------------------------------------------------
+
+    def _load(self, model_id: str) -> None:
+        if self._loading:
+            return
+        self._loading = True
+        self.query_one("#search-status", Static).update(
+            Text(f"inspecting {model_id} … (metadata only, no weights downloaded)", style="#d29922")
+        )
+        self._inspect(model_id)
+
+    @work(thread=True, exclusive=True, group="model-inspect")
+    def _inspect(self, model_id: str) -> None:
+        result = self.app.dispatcher.dispatch(
+            Intent(IntentKind.LOAD_MODEL, {"model_id": model_id}), self.app.ctx
+        )
+        self.app.call_from_thread(self._after_inspect, result)
+
+    def _after_inspect(self, result) -> None:  # noqa: ANN001
+        self._loading = False
+        if result.success:
+            self.app.push_quantize_select()  # decide the plan first; download happens in Execute
+        else:
+            message = (result.message or "could not load model").splitlines()[0]
+            self.query_one("#search-status", Static).update(Text(f"✗ {message}", style="#f85149"))
+
+    def action_back(self) -> None:
+        self.app.pop_screen()

zeroquantz/tui/screens/plan.py

@@ -0,0 +1,177 @@
+"""Plan screen: review the full decision (model + quantization + deploy target)
+before executing. Choosing everything up front, then Execute runs
+download → quantize → deploy.
+"""
+
+from __future__ import annotations
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.text import Text
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Footer, Static
+
+from zeroquantz.deploy import deploy_targets_for, get_target
+from zeroquantz.optimization.planner import MixedPrecisionPlanner
+from zeroquantz.quantization.catalog import get_format
+from zeroquantz.render import render_plan
+from zeroquantz.tui.widgets import Chip
+
+
+class PlanScreen(Screen):
+    BINDINGS = [
+        Binding("escape", "back", "Back"),
+        Binding("enter", "execute", "Execute"),
+        Binding("left", "target_prev", "deploy target", priority=True),
+        Binding("right", "target_next", "deploy target", priority=True, show=False),
+        Binding("r", "save_assets", "Save plan"),
+        Binding("h", "home", "Home"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="plan-page"):
+            with Horizontal(classes="ctl-row"):
+                yield Static("Deploy to", classes="ctl-label")
+            with Horizontal(id="deploy-chips", classes="ctl-row"):
+                yield Static("", id="deploy-chip-holder")
+            with VerticalScroll(id="plan-scroll"):
+                yield Static("", id="plan-body")
+            yield Static("", id="plan-status", classes="page-hint")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        candidate = self.app.selected_candidate
+        fmt = get_format(candidate.format_id) if candidate else None
+        targets = deploy_targets_for(fmt) if fmt else []
+        self._targets = targets
+        # default deploy target: the goal runtime if compatible, else the first.
+        goal_rt = self.app.ctx.session.goal.runtime
+        default = next((t for t in targets if t.name == goal_rt), targets[0] if targets else None)
+        self.app.deploy_target = default.name if default else None
+        holder = self.query_one("#deploy-chips", Horizontal)
+        holder.remove_children()
+        for t in targets:
+            holder.mount(Chip(t.label, group="deploy", value=t.name,
+                              selected=t.name == self.app.deploy_target))
+        self._refresh_body()
+
+    # ---- deploy target selection -------------------------------------------
+
+    @on(Chip.Selected)
+    def _chip(self, event: Chip.Selected) -> None:
+        if event.group == "deploy":
+            self.app.deploy_target = event.value
+            for chip in self.query(Chip):
+                chip.set_selected(chip.chip_value == event.value)
+            self._refresh_body()
+
+    def action_target_next(self) -> None:
+        self._cycle_target(1)
+
+    def action_target_prev(self) -> None:
+        self._cycle_target(-1)
+
+    def _cycle_target(self, direction: int) -> None:
+        if not self._targets:
+            return
+        names = [t.name for t in self._targets]
+        idx = names.index(self.app.deploy_target) if self.app.deploy_target in names else 0
+        self.app.deploy_target = names[(idx + direction) % len(names)]
+        for chip in self.query(Chip):
+            chip.set_selected(chip.chip_value == self.app.deploy_target)
+        self._refresh_body()
+
+    # ---- body ---------------------------------------------------------------
+
+    def _refresh_body(self) -> None:
+        candidate = self.app.selected_candidate
+        ctx = self.app.ctx
+        model = ctx.session.model_profile
+        if candidate is None or model is None:
+            self.query_one("#plan-body", Static).update(Text("Nothing selected.", style="#d29922"))
+            return
+        fmt = get_format(candidate.format_id)
+        target = get_target(self.app.deploy_target) if self.app.deploy_target else None
+
+        fit_ok = candidate.fits_memory
+        header = Text()
+        header.append(f"{model.model_id}  ·  {candidate.label}\n", style="bold #58a6ff")
+        header.append(
+            f"{candidate.estimated_size_gb:.1f} GB · {candidate.estimated_vram_gb:.1f} GB VRAM · "
+            f"quality {candidate.quality_risk_label} · {candidate.estimated_speedup:.1f}x · "
+            f"{candidate.calibration} calibration",
+            style="#8b949e",
+        )
+        header.append("   ")
+        header.append("✓ fits" if fit_ok else "✗ over budget", style="#3fb950" if fit_ok else "#f85149")
+        parts = [Panel(header, title="[b]Quantization[/b]",
+                       border_style="#3fb950" if fit_ok else "#d29922")]
+
+        if target is not None:
+            compatible = target.name in fmt.runtimes
+            dep = Text()
+            dep.append(f"{target.label}", style="bold #58a6ff")
+            dep.append("   ")
+            dep.append("✓ compatible" if compatible else "✗ not supported for this format",
+                       style="#3fb950" if compatible else "#f85149")
+            dep.append(f"\n{target.note}\n\n", style="#8b949e")
+            dep.append("Serve command\n", style="#8b949e")
+            dep.append(f"  {target.serve_command(_deploy_path(ctx, model), fmt)}", style="#3fb950")
+            parts.append(Panel(dep, title="[b]Deploy target[/b]",
+                               border_style="#3fb950" if compatible else "#f85149"))
+
+        if candidate.method == "mixed":
+            plan = MixedPrecisionPlanner.plan(model, ctx.hardware, ctx.session.goal, ctx.sensitivity)
+            ctx.session.plan = plan
+            parts.append(render_plan(plan))
+
+        self.query_one("#plan-body", Static).update(Group(*parts))
+        self.query_one("#plan-status", Static).update(
+            Text("Enter: execute (download → quantize → deploy)   ·   r: save plan & assets only",
+                 style="#6e7681")
+        )
+
+    # ---- actions ------------------------------------------------------------
+
+    def action_execute(self) -> None:
+        self.app.push_execute()
+
+    def action_save_assets(self) -> None:
+        from pathlib import Path
+
+        from zeroquantz.deploy import generate_assets
+        from zeroquantz.export.exporter import Exporter
+        from zeroquantz.export.report import build_report
+
+        ctx = self.app.ctx
+        candidate = self.app.selected_candidate
+        model = ctx.session.model_profile
+        fmt = get_format(candidate.format_id)
+        target = get_target(self.app.deploy_target)
+        name = (ctx.session.model_id or "model").split("/")[-1]
+        out = Path.cwd() / f"zeroquantz-{name}-{candidate.method}"
+        status = self.query_one("#plan-status", Static)
+        try:
+            report = build_report(model, config=candidate.config, hardware=ctx.hardware,
+                                  goal=ctx.session.goal,
+                                  plan=ctx.session.plan if candidate.method == "mixed" else None)
+            Exporter.write_report(report, out)
+            bundle = generate_assets(_deploy_path(ctx, model), fmt, target, out / "deploy")
+            status.update(Text(f"✓ Plan + deploy assets written to {out}", style="#3fb950"))
+        except Exception as exc:  # pragma: no cover
+            status.update(Text(f"✗ {exc}", style="#f85149"))
+
+    def action_back(self) -> None:
+        self.app.pop_screen()
+
+    def action_home(self) -> None:
+        self.app.go_home()
+
+
+def _deploy_path(ctx, model) -> str:  # noqa: ANN001
+    """Path to reference in deploy assets: local quantized dir, else the model id."""
+    return ctx.session.model_local_path or ctx.session.model_id or model.model_id

zeroquantz/tui/screens/quantize_select.py

@@ -0,0 +1,272 @@
+"""Wizard step 2: pick a quantization strategy from the full catalog.
+
+Constraints (budget, context, runtime, objective, filter) are inline **segmented
+chips** above the table — every option is visible; click one (or focus it and
+press Enter) to change it. The fit column, max-context, and ranking update live.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Static
+
+from zeroquantz.optimization.candidate import CandidateGenerator
+from zeroquantz.optimization.constraints import Objective
+from zeroquantz.optimization.recommender import Recommender
+from zeroquantz.tui.widgets import Chip
+from zeroquantz.utils import units
+
+_EXEC_LABEL = {"in_env": "in-env", "isolated": "sub-env", "external": "produce", "planned": "roadmap"}
+_OBJECTIVES = (("Balanced", "balanced"), ("Quality", "quality"), ("Speed", "speed"), ("Memory", "memory"))
+_RUNTIMES = (
+    ("any", "any"), ("vLLM", "vllm"), ("Transformers", "transformers"),
+    ("llama.cpp", "llamacpp"), ("ExLlamaV2", "exllamav2"),
+)
+_CONTEXTS = (1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072)
+
+
+class QuantizeSelectScreen(Screen):
+    BINDINGS = [
+        Binding("escape", "back", "Back"),
+        Binding("enter", "select", "Select"),
+        Binding("left", "obj_prev", "objective", priority=True),
+        Binding("right", "obj_next", "objective", priority=True, show=False),
+        Binding("shift+left", "rt_prev", "runtime", priority=True),
+        Binding("shift+right", "rt_next", "runtime", priority=True, show=False),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._ranked: list = []
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="quant-page"):
+            yield Static("", id="quant-model")
+            with Horizontal(classes="ctl-row"):
+                yield Static("Budget", classes="ctl-label")
+                yield Chip("–", group="budget", value="-")
+                yield Static("", id="budget-value", classes="ctl-value")
+                yield Chip("+", group="budget", value="+")
+                yield Static("Context", classes="ctl-label")
+                yield Chip("–", group="context", value="-")
+                yield Static("", id="context-value", classes="ctl-value")
+                yield Chip("+", group="context", value="+")
+            with Horizontal(classes="ctl-row"):
+                yield Static("Objective", classes="ctl-label")
+                for label, value in _OBJECTIVES:
+                    yield Chip(label, group="objective", value=value)
+                yield Static("Show", classes="ctl-label")
+                yield Chip("all", group="show", value="all")
+                yield Chip("fits", group="show", value="fits")
+            with Horizontal(classes="ctl-row"):
+                yield Static("Runtime", classes="ctl-label")
+                for label, value in _RUNTIMES:
+                    yield Chip(label, group="runtime", value=value)
+            yield DataTable(id="quant-table", cursor_type="row", zebra_stripes=True)
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#quant-table", DataTable)
+        table.add_columns(
+            "Strategy", "bpw", "Size", "VRAM", "Fits", "Max ctx", "Quality", "Speed", "Run", "Exec"
+        )
+        goal = self.app.ctx.session.goal
+        if goal.max_vram_gb is None and self.app.ctx.hardware.total_vram_gb:
+            self.app.ctx.session.goal = goal.with_updates(
+                max_vram_gb=round(self.app.ctx.hardware.total_vram_gb)
+            )
+        self._refresh()
+        self._sync_chips()
+        table.focus()
+
+    # ---- chip interactions --------------------------------------------------
+
+    @on(Chip.Selected)
+    def _chip(self, event: Chip.Selected) -> None:
+        goal = self.app.ctx.session.goal
+        g, v = event.group, event.value
+        if g == "budget":
+            cur = goal.max_vram_gb or 8
+            self.app.ctx.session.goal = goal.with_updates(max_vram_gb=max(1.0, min(256.0, cur + (1 if v == "+" else -1))))
+        elif g == "context":
+            idx = min(range(len(_CONTEXTS)), key=lambda i: abs(_CONTEXTS[i] - goal.context_length))
+            idx = max(0, min(len(_CONTEXTS) - 1, idx + (1 if v == "+" else -1)))
+            self.app.ctx.session.goal = goal.with_updates(context_length=_CONTEXTS[idx])
+        elif g == "objective":
+            self.app.ctx.session.goal = goal.model_copy(update={"objective": Objective(v)})
+        elif g == "runtime":
+            self.app.ctx.session.goal = goal.model_copy(update={"runtime": None if v == "any" else v})
+        elif g == "show":
+            self.app.quant_fits_only = v == "fits"
+        self._refresh()
+        self._sync_chips()
+
+    def action_obj_next(self) -> None:
+        self._cycle_objective(1)
+
+    def action_obj_prev(self) -> None:
+        self._cycle_objective(-1)
+
+    def action_rt_next(self) -> None:
+        self._cycle_runtime(1)
+
+    def action_rt_prev(self) -> None:
+        self._cycle_runtime(-1)
+
+    def _cycle_objective(self, direction: int) -> None:
+        goal = self.app.ctx.session.goal
+        values = [v for _, v in _OBJECTIVES]
+        idx = values.index(str(goal.objective)) if str(goal.objective) in values else 0
+        new = values[(idx + direction) % len(values)]
+        self.app.ctx.session.goal = goal.model_copy(update={"objective": Objective(new)})
+        self._refresh()
+        self._sync_chips()
+
+    def _cycle_runtime(self, direction: int) -> None:
+        goal = self.app.ctx.session.goal
+        values = [v for _, v in _RUNTIMES]
+        current = goal.runtime or "any"
+        idx = values.index(current) if current in values else 0
+        new = values[(idx + direction) % len(values)]
+        self.app.ctx.session.goal = goal.model_copy(update={"runtime": None if new == "any" else new})
+        self._refresh()
+        self._sync_chips()
+
+    def _sync_chips(self) -> None:
+        goal = self.app.ctx.session.goal
+        fits_only = getattr(self.app, "quant_fits_only", False)
+        for chip in self.query(Chip):
+            if chip.chip_group == "objective":
+                chip.set_selected(chip.chip_value == str(goal.objective))
+            elif chip.chip_group == "runtime":
+                chip.set_selected(chip.chip_value == (goal.runtime or "any"))
+            elif chip.chip_group == "show":
+                chip.set_selected(chip.chip_value == ("fits" if fits_only else "all"))
+        self.query_one("#budget-value", Static).update(
+            Text(f"{goal.max_vram_gb:g} GB" if goal.max_vram_gb else "unset", style="bold #3fb950")
+        )
+        self.query_one("#context-value", Static).update(
+            Text(f"{goal.context_length}", style="bold #58a6ff")
+        )
+
+    # ---- table --------------------------------------------------------------
+
+    def _refresh(self) -> None:
+        ctx = self.app.ctx
+        model = ctx.session.model_profile
+        if model is None:
+            self.query_one("#quant-model", Static).update(
+                Text("No model loaded — go back and select one.", style="#d29922")
+            )
+            return
+        goal = ctx.session.goal
+        cands = CandidateGenerator.generate(model, ctx.hardware, goal, registry=ctx.backends)
+        self._ranked = Recommender.rank(cands, goal)
+        best = Recommender.recommend(cands, goal)
+        self._best_id = best.candidate.format_id if best else None
+        self.query_one("#quant-model", Static).update(self._model_text(model))
+
+        fits_only = getattr(self.app, "quant_fits_only", False)
+        # "fits" = fits the budget AND is usable on the selected runtime — not
+        # "auto-runnable" (GGUF/BitNet are produce-only yet still valid choices).
+        rows = [
+            r for r in self._ranked
+            if not fits_only
+            or (r.candidate.fits_memory and r.candidate.runtime_compat.rank >= 1)
+        ]
+        self._rows = rows
+
+        table = self.query_one("#quant-table", DataTable)
+        table.clear()
+        best_row = 0
+        for i, rec in enumerate(rows):
+            c = rec.candidate
+            recommended = c.format_id == self._best_id
+            if recommended:
+                best_row = i
+            strategy = Text(("★ " if recommended else "  ") + c.label,
+                            style="bold white" if recommended else "white")
+            fits = Text("✓", style="#3fb950") if c.fits_memory else Text("✗", style="#f85149")
+            vram = Text(f"{c.estimated_vram_gb:.1f}", style="white" if c.fits_memory else "#f85149")
+            table.add_row(
+                strategy, f"{c.bits_per_weight:.2f}", f"{c.estimated_size_gb:.1f}", vram, fits,
+                _fmt_ctx(c.max_context), Text(c.quality_risk_label, style=_risk_style(c.quality_risk_label)),
+                f"{c.estimated_speedup:.1f}x", _run_cell(c),
+                Text(_EXEC_LABEL.get(c.execution, c.execution), style=_exec_style(c.execution)),
+            )
+        if rows:
+            table.move_cursor(row=min(best_row, len(rows) - 1))
+
+    def _model_text(self, model) -> Text:  # noqa: ANN001
+        text = Text()
+        text.append(model.model_id, style="bold #58a6ff")
+        if model.architecture:
+            text.append(f"   {model.architecture}", style="#8b949e")
+        text.append("\n")
+        parts = [f"{units.humanize_params(model.parameter_count)} params", model.dtype.upper()]
+        if model.num_layers:
+            parts.append(f"{model.num_layers} layers")
+        if model.hidden_size:
+            parts.append(f"hidden {model.hidden_size}")
+        if model.num_attention_heads:
+            heads = f"{model.num_attention_heads} heads"
+            if model.num_key_value_heads and model.num_key_value_heads != model.num_attention_heads:
+                heads += f" (KV {model.num_key_value_heads})"
+            parts.append(heads)
+        parts.append(f"~{model.estimated_weight_size_gb:.1f} GB original")
+        text.append("  ·  ".join(parts), style="#8b949e")
+        return text
+
+    # ---- selection ----------------------------------------------------------
+
+    def action_select(self) -> None:
+        self._select(self.query_one("#quant-table", DataTable).cursor_row)
+
+    @on(DataTable.RowSelected, "#quant-table")
+    def _row_selected(self, event: DataTable.RowSelected) -> None:
+        self._select(event.cursor_row)
+
+    def _select(self, row: int) -> None:
+        rows = getattr(self, "_rows", [])
+        if row is None or row < 0 or row >= len(rows):
+            return
+        candidate = rows[row].candidate
+        self.app.ctx.session.selected_method = candidate.method
+        self.app.ctx.session.selected_format_id = candidate.format_id
+        self.app.push_plan(candidate)
+
+    def action_back(self) -> None:
+        self.app.pop_screen()
+
+
+def _fmt_ctx(n: int | None) -> str:
+    if not n:
+        return "—"
+    return f"{n / 1000:.1f}k" if n >= 1000 else str(n)
+
+
+def _risk_style(label: str) -> str:
+    return {
+        "very low": "#3fb950", "low": "#3fb950", "moderate": "#d29922",
+        "high": "#f85149", "very high": "bold #f85149",
+    }.get(label, "white")
+
+
+def _exec_style(execution: str) -> str:
+    return {"in_env": "#3fb950", "isolated": "#58a6ff", "external": "#d29922", "planned": "#6e7681"}.get(
+        execution, "white"
+    )
+
+
+def _run_cell(candidate) -> Text:  # noqa: ANN001
+    rank = candidate.runtime_compat.rank
+    if rank >= 3:
+        return Text("✓", style="#3fb950")
+    if rank >= 1:
+        return Text("~", style="#d29922")
+    return Text("✗", style="#f85149")