Delete slimshard_gui.py

slimshard_gui.py

@@ -1,1423 +0,0 @@
-#!/usr/bin/env python3
-"""Graphical User Interface for HPC-Quantize V2 SlimShard & CheckFree Recovery.
-
-Launch::
-
-    python3 -m hpc_quantize_v2.slimshard gui
-    # or:
-    python3 -m hpc_quantize_v2.slimshard_gui
-
-Supports any Hugging Face safetensors model architecture (Llama, Qwen2/3,
-Mistral, Mixtral, DeepSeek, Gemma, Phi, GPT-NeoX, Raon, etc.):
-
-1. **CheckFree Single-Shard Recovery (`recover`)**:
-   Reconstructs a complete runnable HF model from a single surviving
-   ``.safetensors`` shard (with optional ``model.safetensors.index.json`` and
-   ``config.json``), using CheckFree depth interpolation, per-expert MXFP8/FP16
-   interpolation, and causal forward-calibrated embedding/LM-head synthesis.
-2. **SlimShard Compression (`build`)**:
-   Compresses any multi-shard HF model into a single self-contained SlimShard
-   (``mixed``, ``q2_k``, ``q4_0``, or ``exact`` + SlimMoE expert clustering).
-3. **SlimShard Regeneration (`regenerate`)**:
-   Restores a standard HF ``.safetensors`` checkpoint from a SlimShard file.
-4. **Live Model Prompt Tester**:
-   Runs any prompt (raw or chat-templated) on the recovered model directly
-   inside the GUI.
-"""
-
-from __future__ import annotations
-
-import datetime as dt
-import queue
-import shlex
-import sys
-import threading
-import time
-import tkinter as tk
-from pathlib import Path
-from tkinter import filedialog, messagebox, ttk
-
-import numpy as np
-
-if __package__ in (None, ""):
-    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-    __package__ = "hpc_quantize_v2"
-
-from .cuda_backend import cuda_device_name, cuda_is_available
-from .slimshard import (
-    HPCConfig,
-    _resolve_shard_paths,
-    build_slimshard,
-    export_hf_bundle,
-    export_safetensors_to_gguf,
-    fetch_minimum_shards_from_hf,
-    inspect_recovery_plan,
-    parse_hf_repo_url,
-    plan_minimum_shards_from_hf,
-    recover_from_shard,
-    regenerate,
-    run_deepseek_v41_generate,
-    slimshard_info,
-)
-
-
-def _ts() -> str:
-    return dt.datetime.now().strftime("%H:%M:%S.%f")[:-3]
-
-
-def _fmt_eta(seconds: float) -> str:
-    if not np.isfinite(seconds) or seconds <= 0.0:
-        return "0s"
-    s = int(round(seconds))
-    if s < 60:
-        return f"{seconds:.1f}s"
-    m, sec = divmod(s, 60)
-    if m < 60:
-        return f"{m}m{sec:02d}s"
-    h, m = divmod(m, 60)
-    return f"{h}h{m:02d}m{sec:02d}s"
-
-
-class SlimShardGUI:
-    def __init__(self, root: tk.Tk | tk.Toplevel) -> None:
-        self.root = root
-        self.root.title(
-            "HPC-Quantize V2 — SlimShard & CheckFree Universal Single-Shard LLM Recovery"
-        )
-        self.root.geometry("1280x920")
-        self.root.minsize(1040, 740)
-
-        self._queue: queue.Queue[tuple[str, object]] = queue.Queue()
-        self._stop_event = threading.Event()
-        self._worker: threading.Thread | None = None
-        self._start_time: float | None = None
-        self._plan_rows: list[dict] = []
-
-        self._init_vars()
-        self._apply_theme()
-        self._build_layout()
-        self._auto_populate_defaults()
-        self._update_cli_preview()
-        self.root.after(80, self._poll_queue)
-
-    def _init_vars(self) -> None:
-        self.op_mode_var = tk.StringVar(value="recover")
-        self.hf_url_var = tk.StringVar(
-            value="https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017/tree/main"
-        )
-        self.hf_fetch_mode_var = tk.StringVar(value="surgical")
-        self.num_anchor_layers_var = tk.IntVar(value=3)
-        self.anchor_layers_var = tk.StringVar(value="")
-        self.shard_var = tk.StringVar()
-        self.index_var = tk.StringVar()
-        self.config_var = tk.StringVar()
-        self.model_dir_var = tk.StringVar()
-        self.output_var = tk.StringVar()
-        self.export_dir_var = tk.StringVar()
-        self.auto_bundle_var = tk.BooleanVar(value=True)
-
-        self.device_var = tk.StringVar(value="auto")
-        self.quant_format_var = tk.StringVar(value="mixed")
-        self.expert_keep_var = tk.DoubleVar(value=1.0)
-        self.target_params_b_var = tk.DoubleVar(value=30.0)
-        self.max_experts_var = tk.IntVar(value=0)
-
-        self.filter_action_var = tk.StringVar(value="ALL")
-        self.search_var = tk.StringVar()
-
-        # Live telemetry variables
-        self.arch_summary_var = tk.StringVar(value="No shard inspected yet.")
-        self.layers_summary_var = tk.StringVar(value="Surviving layers: -- | Missing layers: --")
-        self.tele_tensor_var = tk.StringVar(value="Idle")
-        self.tele_action_var = tk.StringVar(value="Waiting")
-        self.tele_progress_text_var = tk.StringVar(value="0 / 0")
-        self.tele_breakdown_var = tk.StringVar(
-            value="present=0 | layer_interp=0 | expert_interp=0 | synth=0"
-        )
-        self.tele_speed_var = tk.StringVar(value="0.0 ten/s (ETA --)")
-        self.tele_elapsed_var = tk.StringVar(value="0.0s")
-        self.progress_var = tk.DoubleVar(value=0.0)
-        self.status_var = tk.StringVar(value="Ready.")
-        self.cli_preview_var = tk.StringVar()
-
-        # Prompt test variables
-        self.test_model_dir_var = tk.StringVar()
-        self.test_prompt_var = tk.StringVar(value="hello")
-        self.test_chat_mode_var = tk.BooleanVar(value=False)
-        self.test_max_tokens_var = tk.IntVar(value=24)
-
-        for v in (
-            self.op_mode_var,
-            self.hf_url_var,
-            self.hf_fetch_mode_var,
-            self.num_anchor_layers_var,
-            self.anchor_layers_var,
-            self.shard_var,
-            self.index_var,
-            self.config_var,
-            self.model_dir_var,
-            self.output_var,
-            self.export_dir_var,
-            self.auto_bundle_var,
-            self.device_var,
-            self.quant_format_var,
-            self.expert_keep_var,
-            self.target_params_b_var,
-            self.max_experts_var,
-        ):
-            v.trace_add("write", lambda *_: self._update_cli_preview())
-
-    def _apply_theme(self) -> None:
-        style = ttk.Style(self.root)
-        if "clam" in style.theme_names():
-            style.theme_use("clam")
-        bg = "#141820"
-        panel = "#1c222d"
-        fg = "#e6edf3"
-        accent = "#3b82f6"
-        self.root.configure(bg=bg)
-        style.configure(".", background=bg, foreground=fg, fieldbackground=panel)
-        style.configure("TFrame", background=bg)
-        style.configure("TLabelframe", background=bg, foreground=fg)
-        style.configure(
-            "TLabelframe.Label",
-            background=bg,
-            foreground="#93c5fd",
-            font=("Sans", 10, "bold"),
-        )
-        style.configure("TLabel", background=bg, foreground=fg)
-        style.configure(
-            "TeleKey.TLabel", background=bg, foreground="#9ca3af", font=("Sans", 9)
-        )
-        style.configure(
-            "TeleVal.TLabel",
-            background=bg,
-            foreground="#60a5fa",
-            font=("Monospace", 9, "bold"),
-        )
-        style.configure("TCheckbutton", background=bg, foreground=fg)
-        style.configure("TRadiobutton", background=bg, foreground=fg)
-        style.configure("TButton", background=panel, foreground=fg, padding=(10, 5))
-        style.map("TButton", background=[("active", accent)])
-        style.configure(
-            "Accent.TButton",
-            background=accent,
-            foreground="#ffffff",
-            font=("Sans", 10, "bold"),
-        )
-        style.configure(
-            "Treeview",
-            background=panel,
-            fieldbackground=panel,
-            foreground=fg,
-            rowheight=23,
-        )
-        style.configure(
-            "Treeview.Heading",
-            background="#262f3f",
-            foreground=fg,
-            font=("Sans", 9, "bold"),
-        )
-        style.map("Treeview", background=[("selected", accent)])
-
-    def _build_layout(self) -> None:
-        outer = ttk.Frame(self.root)
-        outer.pack(fill=tk.BOTH, expand=True)
-        outer.rowconfigure(0, weight=1)
-        outer.columnconfigure(0, weight=1)
-
-        self._canvas = tk.Canvas(outer, bg="#141820", highlightthickness=0)
-        v_scroll = ttk.Scrollbar(outer, orient=tk.VERTICAL, command=self._canvas.yview)
-        h_scroll = ttk.Scrollbar(
-            outer, orient=tk.HORIZONTAL, command=self._canvas.xview
-        )
-        self._canvas.configure(yscrollcommand=v_scroll.set, xscrollcommand=h_scroll.set)
-
-        self._canvas.grid(row=0, column=0, sticky=tk.NSEW)
-        v_scroll.grid(row=0, column=1, sticky=tk.NS)
-        h_scroll.grid(row=1, column=0, sticky=tk.EW)
-
-        main = ttk.Frame(self._canvas, padding=10)
-        self._canvas_win = self._canvas.create_window((0, 0), window=main, anchor=tk.NW)
-
-        def _on_frame_configure(_event=None) -> None:
-            self._canvas.configure(scrollregion=self._canvas.bbox("all"))
-
-        def _on_canvas_configure(event) -> None:
-            req_w = max(event.width, main.winfo_reqwidth())
-            req_h = max(event.height, main.winfo_reqheight())
-            self._canvas.itemconfigure(self._canvas_win, width=req_w, height=req_h)
-
-        main.bind("<Configure>", _on_frame_configure)
-        self._canvas.bind("<Configure>", _on_canvas_configure)
-
-        # 1. Mode & File Paths Card
-        io_frame = ttk.LabelFrame(
-            main,
-            text=" 1. Operation Mode & Model Paths (Works on Any HF Model Architecture) ",
-            padding=10,
-        )
-        io_frame.pack(fill=tk.X, pady=(0, 8))
-        io_frame.columnconfigure(1, weight=1)
-
-        mode_bar = ttk.Frame(io_frame)
-        mode_bar.grid(row=0, column=0, columnspan=3, sticky=tk.W, pady=(0, 8))
-        ttk.Label(mode_bar, text="Workflow:", font=("Sans", 9, "bold")).pack(
-            side=tk.LEFT, padx=(0, 10)
-        )
-        ttk.Radiobutton(
-            mode_bar,
-            text="CheckFree Multi/Single-Shard Recovery (Shards -> Full Model)",
-            variable=self.op_mode_var,
-            value="recover",
-        ).pack(side=tk.LEFT, padx=(0, 14))
-        ttk.Radiobutton(
-            mode_bar,
-            text="Retrieve Minimum Shards from HF Link",
-            variable=self.op_mode_var,
-            value="fetch-hf",
-        ).pack(side=tk.LEFT, padx=(0, 14))
-        ttk.Radiobutton(
-            mode_bar,
-            text="Build Self-Contained SlimShard (Multi-Shard -> 1 SlimShard)",
-            variable=self.op_mode_var,
-            value="build",
-        ).pack(side=tk.LEFT, padx=(0, 14))
-        ttk.Radiobutton(
-            mode_bar,
-            text="Regenerate from SlimShard",
-            variable=self.op_mode_var,
-            value="regenerate",
-        ).pack(side=tk.LEFT, padx=(0, 14))
-        ttk.Radiobutton(
-            mode_bar,
-            text="Export SafeTensors to GGUF (Q2_K / Q4_0 / BF16)",
-            variable=self.op_mode_var,
-            value="export-gguf",
-        ).pack(side=tk.LEFT)
-
-        # Hugging Face Link Minimum-Shard Retriever Bar
-        hf_bar = ttk.Frame(io_frame)
-        hf_bar.grid(row=1, column=0, columnspan=3, sticky=tk.EW, pady=(0, 6))
-        hf_bar.columnconfigure(1, weight=1)
-        ttk.Label(
-            hf_bar, text="Hugging Face Link / Repo:", font=("Sans", 9, "bold")
-        ).grid(row=0, column=0, sticky=tk.W, padx=(0, 6))
-        ttk.Entry(hf_bar, textvariable=self.hf_url_var).grid(
-            row=0, column=1, sticky=tk.EW, padx=(0, 8)
-        )
-        ttk.Combobox(
-            hf_bar,
-            textvariable=self.hf_fetch_mode_var,
-            values=("surgical", "full_shards"),
-            width=12,
-            state="readonly",
-        ).grid(row=0, column=2, padx=(0, 6))
-        ttk.Button(
-            hf_bar, text="Analyze Min Shards", command=self._analyze_hf_min_shards
-        ).grid(row=0, column=3, padx=(0, 6))
-        ttk.Button(
-            hf_bar,
-            text="Retrieve Min Shards",
-            style="Accent.TButton",
-            command=self._retrieve_hf_min_shards,
-        ).grid(row=0, column=4)
-
-        self._add_path_row(
-            io_frame,
-            2,
-            "Surviving Shard(s) / Input (.safetensors, comma-sep):",
-            self.shard_var,
-            self._pick_shard,
-        )
-        self._add_path_row(
-            io_frame,
-            3,
-            "Index JSON (optional, auto-inferred if omitted):",
-            self.index_var,
-            self._pick_index,
-        )
-        self._add_path_row(
-            io_frame,
-            4,
-            "Config JSON (auto-detected from folder):",
-            self.config_var,
-            self._pick_config,
-        )
-        self._add_path_row(
-            io_frame,
-            5,
-            "Source / Download Model Dir:",
-            self.model_dir_var,
-            self._pick_model_dir,
-        )
-        self._add_path_row(
-            io_frame,
-            6,
-            "Output .safetensors / .gguf File:",
-            self.output_var,
-            self._pick_output,
-        )
-        self._add_path_row(
-            io_frame,
-            7,
-            "Export Ready-to-Run HF Bundle Dir:",
-            self.export_dir_var,
-            self._pick_export_dir,
-        )
-
-        # 2. Options & Execution Controls
-        opt_frame = ttk.LabelFrame(
-            main, text=" 2. CheckFree / SlimShard Engine Parameters ", padding=10
-        )
-        opt_frame.pack(fill=tk.X, pady=(0, 8))
-
-        row_opt = ttk.Frame(opt_frame)
-        row_opt.pack(fill=tk.X)
-
-        gpu_lbl = (
-            f"CUDA ({cuda_device_name()})" if cuda_is_available() else "CPU only"
-        )
-        ttk.Label(row_opt, text=f"Compute Device [{gpu_lbl}]:").pack(
-            side=tk.LEFT, padx=(0, 6)
-        )
-        ttk.Combobox(
-            row_opt,
-            textvariable=self.device_var,
-            values=("auto", "cuda", "cpu"),
-            width=8,
-            state="readonly",
-        ).pack(side=tk.LEFT, padx=(0, 16))
-
-        ttk.Label(row_opt, text="Format:").pack(side=tk.LEFT, padx=(0, 6))
-        ttk.Combobox(
-            row_opt,
-            textvariable=self.quant_format_var,
-            values=("mixed", "q2_k", "q4_0", "bf16", "exact"),
-            width=9,
-            state="readonly",
-        ).pack(side=tk.LEFT, padx=(0, 16))
-
-        ttk.Label(row_opt, text="Target Params (B, 0=full):").pack(
-            side=tk.LEFT, padx=(0, 6)
-        )
-        ttk.Spinbox(
-            row_opt,
-            from_=0.0,
-            to=600.0,
-            increment=1.0,
-            textvariable=self.target_params_b_var,
-            width=6,
-        ).pack(side=tk.LEFT, padx=(0, 14))
-
-        ttk.Label(row_opt, text="Max Experts/Layer (0=auto):").pack(
-            side=tk.LEFT, padx=(0, 6)
-        )
-        ttk.Spinbox(
-            row_opt,
-            from_=0,
-            to=512,
-            increment=1,
-            textvariable=self.max_experts_var,
-            width=5,
-        ).pack(side=tk.LEFT, padx=(0, 14))
-
-        ttk.Label(row_opt, text="# Anchor Layers:").pack(
-            side=tk.LEFT, padx=(0, 4)
-        )
-        ttk.Spinbox(
-            row_opt,
-            from_=1,
-            to=128,
-            increment=1,
-            textvariable=self.num_anchor_layers_var,
-            width=4,
-        ).pack(side=tk.LEFT, padx=(0, 10))
-
-        ttk.Label(row_opt, text="Anchor Layers (e.g. 0,14,39):").pack(
-            side=tk.LEFT, padx=(0, 4)
-        )
-        ttk.Entry(
-            row_opt,
-            textvariable=self.anchor_layers_var,
-            width=12,
-        ).pack(side=tk.LEFT, padx=(0, 12))
-
-        ttk.Label(row_opt, text="SlimMoE Keep Ratio:").pack(
-            side=tk.LEFT, padx=(0, 6)
-        )
-        ttk.Spinbox(
-            row_opt,
-            from_=0.10,
-            to=1.00,
-            increment=0.05,
-            textvariable=self.expert_keep_var,
-            width=6,
-        ).pack(side=tk.LEFT, padx=(0, 14))
-
-        ttk.Checkbutton(
-            row_opt,
-            text="Export HF Bundle Dir",
-            variable=self.auto_bundle_var,
-        ).pack(side=tk.LEFT, padx=(0, 8))
-
-        btn_bar = ttk.Frame(opt_frame)
-        btn_bar.pack(fill=tk.X, pady=(8, 0))
-        ttk.Button(
-            btn_bar,
-            text="Inspect Shard & Recovery Plan",
-            command=self._inspect_plan,
-        ).pack(side=tk.LEFT, padx=(0, 8))
-        self.run_btn = ttk.Button(
-            btn_bar,
-            text="Run Recovery / Build",
-            style="Accent.TButton",
-            command=self._start_run,
-        )
-        self.run_btn.pack(side=tk.LEFT, padx=(0, 8))
-        self.stop_btn = ttk.Button(
-            btn_bar, text="Stop", command=self._stop_run, state=tk.DISABLED
-        )
-        self.stop_btn.pack(side=tk.LEFT, padx=(0, 14))
-        ttk.Entry(btn_bar, textvariable=self.cli_preview_var, state="readonly").pack(
-            side=tk.LEFT, fill=tk.X, expand=True
-        )
-
-        # 3. Telemetry Dashboard
-        tele = ttk.LabelFrame(main, text=" 3. Real-Time Telemetry ", padding=10)
-        tele.pack(fill=tk.X, pady=(0, 8))
-        tele.columnconfigure(1, weight=1)
-        tele.columnconfigure(3, weight=1)
-
-        ttk.Label(tele, text="Architecture:", style="TeleKey.TLabel").grid(
-            row=0, column=0, sticky=tk.W
-        )
-        ttk.Label(tele, textvariable=self.arch_summary_var, style="TeleVal.TLabel").grid(
-            row=0, column=1, columnspan=3, sticky=tk.W, padx=(6, 0)
-        )
-
-        ttk.Label(tele, text="Layer Coverage:", style="TeleKey.TLabel").grid(
-            row=1, column=0, sticky=tk.W, pady=(3, 0)
-        )
-        ttk.Label(
-            tele, textvariable=self.layers_summary_var, style="TeleVal.TLabel"
-        ).grid(row=1, column=1, columnspan=3, sticky=tk.W, padx=(6, 0), pady=(3, 0))
-
-        ttk.Label(tele, text="Active Tensor:", style="TeleKey.TLabel").grid(
-            row=2, column=0, sticky=tk.W, pady=(3, 0)
-        )
-        ttk.Label(tele, textvariable=self.tele_tensor_var, style="TeleVal.TLabel").grid(
-            row=2, column=1, sticky=tk.W, padx=(6, 0), pady=(3, 0)
-        )
-        ttk.Label(tele, text="Stage / Action:", style="TeleKey.TLabel").grid(
-            row=2, column=2, sticky=tk.W, pady=(3, 0)
-        )
-        ttk.Label(tele, textvariable=self.tele_action_var, style="TeleVal.TLabel").grid(
-            row=2, column=3, sticky=tk.W, padx=(6, 0), pady=(3, 0)
-        )
-
-        ttk.Label(tele, text="Progress:", style="TeleKey.TLabel").grid(
-            row=3, column=0, sticky=tk.W, pady=(3, 0)
-        )
-        ttk.Label(
-            tele, textvariable=self.tele_progress_text_var, style="TeleVal.TLabel"
-        ).grid(row=3, column=1, sticky=tk.W, padx=(6, 0), pady=(3, 0))
-        ttk.Label(tele, text="Throughput / ETA:", style="TeleKey.TLabel").grid(
-            row=3, column=2, sticky=tk.W, pady=(3, 0)
-        )
-        ttk.Label(tele, textvariable=self.tele_speed_var, style="TeleVal.TLabel").grid(
-            row=3, column=3, sticky=tk.W, padx=(6, 0), pady=(3, 0)
-        )
-
-        ttk.Label(tele, text="Breakdown:", style="TeleKey.TLabel").grid(
-            row=4, column=0, sticky=tk.W, pady=(3, 0)
-        )
-        ttk.Label(
-            tele, textvariable=self.tele_breakdown_var, style="TeleVal.TLabel"
-        ).grid(row=4, column=1, sticky=tk.W, padx=(6, 0), pady=(3, 0))
-        ttk.Label(tele, text="Elapsed:", style="TeleKey.TLabel").grid(
-            row=4, column=2, sticky=tk.W, pady=(3, 0)
-        )
-        ttk.Label(
-            tele, textvariable=self.tele_elapsed_var, style="TeleVal.TLabel"
-        ).grid(row=4, column=3, sticky=tk.W, padx=(6, 0), pady=(3, 0))
-
-        ttk.Progressbar(
-            tele, variable=self.progress_var, maximum=100.0, mode="determinate"
-        ).grid(row=5, column=0, columnspan=4, sticky=tk.EW, pady=(8, 0))
-
-        # 4. Tensor Recovery Plan Table
-        tbl_frame = ttk.LabelFrame(
-            main, text=" 4. Tensor Recovery Plan & Status ", padding=10
-        )
-        tbl_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 8))
-
-        fbar = ttk.Frame(tbl_frame)
-        fbar.pack(fill=tk.X, pady=(0, 6))
-        ttk.Label(fbar, text="Filter Action:").pack(side=tk.LEFT, padx=(0, 6))
-        cb_filter = ttk.Combobox(
-            fbar,
-            textvariable=self.filter_action_var,
-            values=(
-                "ALL",
-                "PRESENT",
-                "CHECKFREE_LAYER",
-                "CHECKFREE_EXPERT",
-                "SYNTHESIZE_CALIBRATED",
-                "SUFFIX_PRIOR",
-            ),
-            width=22,
-            state="readonly",
-        )
-        cb_filter.pack(side=tk.LEFT, padx=(0, 14))
-        cb_filter.bind("<<ComboboxSelected>>", lambda *_: self._refresh_table())
-
-        ttk.Label(fbar, text="Search Tensor:").pack(side=tk.LEFT, padx=(0, 6))
-        ent_search = ttk.Entry(fbar, textvariable=self.search_var, width=32)
-        ent_search.pack(side=tk.LEFT, padx=(0, 8))
-        ent_search.bind("<KeyRelease>", lambda *_: self._refresh_table())
-
-        cols = ("idx", "name", "layer", "role", "shard", "action", "dtype", "status")
-        self.tree = ttk.Treeview(
-            tbl_frame, columns=cols, show="headings", height=10, selectmode="browse"
-        )
-        headers = {
-            "idx": ("#", 55),
-            "name": ("Tensor Name", 410),
-            "layer": ("Layer", 65),
-            "role": ("Role", 150),
-            "shard": ("Original Shard", 210),
-            "action": ("Recovery Strategy", 170),
-            "dtype": ("Dtype", 80),
-            "status": ("Status", 95),
-        }
-        for c, (label, w) in headers.items():
-            self.tree.heading(c, text=label)
-            self.tree.column(c, width=w, anchor=tk.W if c != "idx" else tk.E)
-
-        t_scroll = ttk.Scrollbar(tbl_frame, orient=tk.VERTICAL, command=self.tree.yview)
-        self.tree.configure(yscrollcommand=t_scroll.set)
-        self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
-        t_scroll.pack(side=tk.RIGHT, fill=tk.Y)
-
-        # 5. Universal Recovered Model Prompt Tester + Log
-        bottom_pane = ttk.PanedWindow(main, orient=tk.HORIZONTAL)
-        bottom_pane.pack(fill=tk.BOTH, expand=True)
-
-        test_frame = ttk.LabelFrame(
-            bottom_pane,
-            text=" 5. Test Recovered Model (Works on Any HF CausalLM) ",
-            padding=10,
-        )
-        bottom_pane.add(test_frame, weight=1)
-
-        t_row1 = ttk.Frame(test_frame)
-        t_row1.pack(fill=tk.X, pady=(0, 4))
-        ttk.Label(t_row1, text="Model Dir:").pack(side=tk.LEFT, padx=(0, 6))
-        ttk.Entry(t_row1, textvariable=self.test_model_dir_var).pack(
-            side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 6)
-        )
-        ttk.Button(t_row1, text="Browse", command=self._pick_test_dir).pack(
-            side=tk.LEFT
-        )
-
-        t_row2 = ttk.Frame(test_frame)
-        t_row2.pack(fill=tk.X, pady=(0, 4))
-        ttk.Label(t_row2, text="Prompt:").pack(side=tk.LEFT, padx=(0, 6))
-        ttk.Entry(t_row2, textvariable=self.test_prompt_var).pack(
-            side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 8)
-        )
-        ttk.Checkbutton(
-            t_row2, text="Chat Template", variable=self.test_chat_mode_var
-        ).pack(side=tk.LEFT, padx=(0, 8))
-        ttk.Label(t_row2, text="Max Tokens:").pack(side=tk.LEFT, padx=(0, 4))
-        ttk.Spinbox(
-            t_row2, from_=1, to=256, textvariable=self.test_max_tokens_var, width=5
-        ).pack(side=tk.LEFT, padx=(0, 8))
-        self.test_btn = ttk.Button(
-            t_row2,
-            text="Run Prompt",
-            style="Accent.TButton",
-            command=self._run_prompt_test,
-        )
-        self.test_btn.pack(side=tk.LEFT)
-
-        self.test_out_text = tk.Text(
-            test_frame,
-            height=8,
-            bg="#0f131a",
-            fg="#a7f3d0",
-            insertbackground="#ffffff",
-            font=("Monospace", 9),
-            wrap=tk.WORD,
-        )
-        self.test_out_text.pack(fill=tk.BOTH, expand=True)
-
-        log_frame = ttk.LabelFrame(bottom_pane, text=" 6. Event Log ", padding=10)
-        bottom_pane.add(log_frame, weight=1)
-        self.log_text = tk.Text(
-            log_frame,
-            height=8,
-            bg="#0f131a",
-            fg="#e6edf3",
-            insertbackground="#ffffff",
-            font=("Monospace", 9),
-            wrap=tk.WORD,
-        )
-        self.log_text.pack(fill=tk.BOTH, expand=True)
-
-    def _add_path_row(
-        self, parent: ttk.Frame, row: int, label: str, var: tk.StringVar, cmd
-    ) -> None:
-        ttk.Label(parent, text=label).grid(row=row, column=0, sticky=tk.W, pady=2)
-        ttk.Entry(parent, textvariable=var).grid(
-            row=row, column=1, sticky=tk.EW, padx=6, pady=2
-        )
-        ttk.Button(parent, text="Browse...", command=cmd).grid(
-            row=row, column=2, sticky=tk.E, pady=2
-        )
-
-    def _auto_populate_defaults(self) -> None:
-        repo_root = Path(__file__).resolve().parent.parent
-        for base in (Path.cwd(), repo_root):
-            raon_shard = base / "Raon-1-mini-preview" / "model-00001-of-00007.safetensors"
-            if raon_shard.exists():
-                self._set_shard_and_companions(raon_shard)
-                return
-            shards = sorted(base.glob("*/*.safetensors"))
-            if shards:
-                self._set_shard_and_companions(shards[0])
-                return
-
-    def _set_shard_and_companions(self, shard_path: Path) -> None:
-        self.shard_var.set(str(shard_path))
-        parent = shard_path.parent
-        self.model_dir_var.set(str(parent))
-        idx = parent / "model.safetensors.index.json"
-        if idx.exists():
-            self.index_var.set(str(idx))
-        cfg = parent / "config.json"
-        if cfg.exists():
-            self.config_var.set(str(cfg))
-        if not self.output_var.get():
-            self.output_var.set(str(Path.cwd() / f"{parent.name}-recovered.safetensors"))
-        if not self.export_dir_var.get():
-            self.export_dir_var.set(str(Path.cwd() / f"recovered_{parent.name.lower().replace('-', '_')}"))
-            self.test_model_dir_var.set(self.export_dir_var.get())
-
-    def _pick_shard(self) -> None:
-        ps = filedialog.askopenfilenames(
-            title="Select Surviving .safetensors Shard(s) (Multi-Select Supported)",
-            filetypes=[("SafeTensors", "*.safetensors"), ("All files", "*.*")],
-        )
-        if ps:
-            paths = [Path(p) for p in ps]
-            self._set_shard_and_companions(paths[0])
-            self.shard_var.set(", ".join(str(p) for p in paths))
-            self._inspect_plan()
-
-    def _analyze_hf_min_shards(self) -> None:
-        url = self.hf_url_var.get().strip()
-        if not url:
-            messagebox.showwarning("SlimShard", "Please enter a Hugging Face link or repo ID first.")
-            return
-        try:
-            tp = float(self.target_params_b_var.get())
-        except Exception:
-            tp = 0.0
-        try:
-            me = int(self.max_experts_var.get())
-        except Exception:
-            me = 0
-        try:
-            n_anc = int(self.num_anchor_layers_var.get())
-        except Exception:
-            n_anc = 3
-        anc_str = self.anchor_layers_var.get().strip() or None
-
-        self._log(f"Analyzing minimum shards on Hugging Face for {url}...")
-        try:
-            plan = plan_minimum_shards_from_hf(
-                url,
-                target_params_b=tp if tp > 0.0 else None,
-                max_experts=me if me > 0 else None,
-                num_anchor_layers=n_anc,
-                anchor_layers=anc_str,
-            )
-        except Exception as exc:
-            self._log(f"HF Analyze Failed: {exc}")
-            messagebox.showerror("HF Minimum Shards Analysis Failed", str(exc))
-            return
-
-        repo_name = plan["repo_id"].split("/")[-1]
-        if not self.model_dir_var.get().strip():
-            self.model_dir_var.set(str(Path.cwd() / repo_name))
-        if not self.output_var.get().strip():
-            self.output_var.set(str(Path.cwd() / repo_name / "model.safetensors"))
-        if not self.export_dir_var.get().strip():
-            self.export_dir_var.set(str(Path.cwd() / f"recovered_{repo_name.lower().replace('-', '_')}"))
-
-        min_sh = plan["minimum_shards"]
-        tot_sh = plan["total_repo_shards"]
-        anchors = plan["anchor_layers"]
-        archs = ",".join(plan["architectures"]) or plan["model_type"]
-        self.arch_summary_var.set(
-            f"{plan['repo_id']} ({archs} | ~{plan['estimated_params_b']}B target | "
-            f"layers={plan['num_hidden_layers']}, experts={plan['kept_experts']}/{plan['orig_num_experts']})"
-        )
-        self.layers_summary_var.set(
-            f"Minimum Shards Needed: {len(min_sh)} / {tot_sh} ({', '.join(min_sh)})  |  "
-            f"Anchor Layers ({len(anchors)}): {anchors}"
-        )
-        self.tele_breakdown_var.set(
-            f"min_shards={len(min_sh)}/{tot_sh} | surgical_tensors={plan['surgical_tensor_count']} | "
-            f"full_repo={plan['total_repo_size_gb']} GB"
-        )
-        roles_lines = [
-            f"  - {sh}: {', '.join(plan['shard_roles'].get(sh, []))}" for sh in min_sh
-        ]
-        msg = (
-            f"HF Repo: {plan['repo_id']}@{plan['revision']}\n"
-            f"Minimum Shards Required: {len(min_sh)} of {tot_sh} shards\n"
-            f"Selected Anchor Layers: {anchors}\n"
-            f"Surgical Tensor Count: {plan['surgical_tensor_count']} tensors\n"
-            + "\n".join(roles_lines)
-        )
-        self._log(msg)
-
-    def _retrieve_hf_min_shards(self) -> None:
-        self.op_mode_var.set("fetch-hf")
-        if not self.model_dir_var.get().strip():
-            try:
-                repo_id, _ = parse_hf_repo_url(self.hf_url_var.get().strip())
-                self.model_dir_var.set(str(Path.cwd() / repo_id.split("/")[-1]))
-            except Exception:
-                self.model_dir_var.set(str(Path.cwd() / "hf_min_shards"))
-        if not self.output_var.get().strip():
-            self.output_var.set(str(Path(self.model_dir_var.get().strip()) / "model.safetensors"))
-        self._start_run()
-
-    def _pick_index(self) -> None:
-        p = filedialog.askopenfilename(
-            title="Select model.safetensors.index.json",
-            filetypes=[("JSON", "*.json"), ("All files", "*.*")],
-        )
-        if p:
-            self.index_var.set(p)
-
-    def _pick_config(self) -> None:
-        p = filedialog.askopenfilename(
-            title="Select config.json",
-            filetypes=[("JSON", "*.json"), ("All files", "*.*")],
-        )
-        if p:
-            self.config_var.set(p)
-
-    def _pick_model_dir(self) -> None:
-        p = filedialog.askdirectory(title="Select HF Model Directory")
-        if p:
-            self.model_dir_var.set(p)
-
-    def _pick_output(self) -> None:
-        p = filedialog.asksaveasfilename(
-            title="Select Output .safetensors Path",
-            defaultextension=".safetensors",
-            filetypes=[("SafeTensors", "*.safetensors"), ("All files", "*.*")],
-        )
-        if p:
-            self.output_var.set(p)
-
-    def _pick_export_dir(self) -> None:
-        p = filedialog.askdirectory(title="Select Export HF Bundle Directory")
-        if p:
-            self.export_dir_var.set(p)
-            self.test_model_dir_var.set(p)
-
-    def _pick_test_dir(self) -> None:
-        p = filedialog.askdirectory(title="Select Recovered HF Model Directory")
-        if p:
-            self.test_model_dir_var.set(p)
-
-    def _update_cli_preview(self) -> None:
-        mode = self.op_mode_var.get()
-        cmd = ["python3", "-m", "hpc_quantize_v2.slimshard", mode]
-        if mode == "recover":
-            if self.shard_var.get():
-                cmd += ["--shard", self.shard_var.get()]
-            if self.index_var.get():
-                cmd += ["--index", self.index_var.get()]
-            if self.config_var.get():
-                cmd += ["--config", self.config_var.get()]
-            if self.output_var.get():
-                cmd += ["--output", self.output_var.get()]
-            if self.auto_bundle_var.get() and self.export_dir_var.get():
-                cmd += ["--export-hf-dir", self.export_dir_var.get()]
-            try:
-                tp = float(self.target_params_b_var.get())
-                if tp > 0.0:
-                    cmd += ["--target-params-b", f"{tp:g}"]
-            except Exception:
-                pass
-            try:
-                me = int(self.max_experts_var.get())
-                if me > 0:
-                    cmd += ["--max-experts", str(me)]
-            except Exception:
-                pass
-            if self.anchor_layers_var.get().strip():
-                cmd += ["--anchor-layers", self.anchor_layers_var.get().strip()]
-            cmd += ["--device", self.device_var.get()]
-        elif mode == "fetch-hf":
-            if self.hf_url_var.get().strip():
-                cmd += ["--repo", self.hf_url_var.get().strip()]
-            if self.model_dir_var.get().strip():
-                cmd += ["--output-dir", self.model_dir_var.get().strip()]
-            try:
-                tp = float(self.target_params_b_var.get())
-                if tp > 0.0:
-                    cmd += ["--target-params-b", f"{tp:g}"]
-            except Exception:
-                pass
-            try:
-                me = int(self.max_experts_var.get())
-                if me > 0:
-                    cmd += ["--max-experts", str(me)]
-            except Exception:
-                pass
-            try:
-                na = int(self.num_anchor_layers_var.get())
-                cmd += ["--num-anchor-layers", str(na)]
-            except Exception:
-                pass
-            if self.anchor_layers_var.get().strip():
-                cmd += ["--anchor-layers", self.anchor_layers_var.get().strip()]
-            cmd += ["--mode", self.hf_fetch_mode_var.get()]
-        elif mode == "build":
-            if self.model_dir_var.get():
-                cmd += ["--model-dir", self.model_dir_var.get()]
-            if self.output_var.get():
-                cmd += ["--output", self.output_var.get()]
-            cmd += [
-                "--format",
-                self.quant_format_var.get(),
-                "--expert-keep-ratio",
-                f"{self.expert_keep_var.get():.2f}",
-                "--device",
-                self.device_var.get(),
-            ]
-        else:
-            if self.shard_var.get():
-                cmd += ["--input", self.shard_var.get()]
-            if self.output_var.get():
-                cmd += ["--output", self.output_var.get()]
-        self.cli_preview_var.set(" ".join(shlex.quote(x) for x in cmd))
-
-    def _log(self, msg: str) -> None:
-        self.log_text.insert(tk.END, f"[{_ts()}] {msg}\n")
-        self.log_text.see(tk.END)
-
-    def _inspect_plan(self) -> None:
-        shard = self.shard_var.get().strip()
-        try:
-            resolved = _resolve_shard_paths(shard) if shard else []
-        except Exception:
-            resolved = []
-        if not resolved:
-            messagebox.showwarning("SlimShard", "Please select one or more valid .safetensors shards first.")
-            return
-        try:
-            tp = float(self.target_params_b_var.get())
-        except Exception:
-            tp = 0.0
-        try:
-            me = int(self.max_experts_var.get())
-        except Exception:
-            me = 0
-        try:
-            plan = inspect_recovery_plan(
-                shard,
-                index=self.index_var.get().strip() or None,
-                config=self.config_var.get().strip() or None,
-                target_params_b=tp if tp > 0.0 else None,
-                max_experts=me if me > 0 else None,
-                anchor_layers=self.anchor_layers_var.get().strip() or None,
-            )
-        except Exception as exc:
-            messagebox.showerror("Inspect Failed", str(exc))
-            return
-
-        archs = ",".join(plan["architectures"]) or plan["model_type"]
-        orig_e = plan.get("orig_num_experts", plan["num_experts"])
-        exp_str = (
-            f"{plan['num_experts']}/{orig_e}"
-            if plan["num_experts"] != orig_e
-            else str(plan["num_experts"])
-        )
-        self.arch_summary_var.set(
-            f"{archs} (~{plan.get('estimated_params_b', 0)}B params | type={plan['model_type']}, "
-            f"hidden={plan['hidden_size']}, layers={plan['num_hidden_layers']}, "
-            f"experts={exp_str}, vocab={plan['vocab_size']}, tensors={plan['total_tensors']})"
-        )
-        surv = plan["surviving_layers"]
-        miss = plan["missing_layers"]
-        self.layers_summary_var.set(
-            f"Surviving across {len(resolved)} shard(s) ({len(surv)}): {surv[:12]}{'...' if len(surv) > 12 else ''}  |  "
-            f"Missing to CheckFree-reconstruct ({len(miss)}): {miss[:12]}{'...' if len(miss) > 12 else ''}"
-        )
-        c = plan["counts"]
-        self.tele_breakdown_var.set(
-            f"present={c.get('PRESENT', 0)} | layer_interp={c.get('CHECKFREE_LAYER', 0)} | "
-            f"expert_interp={c.get('CHECKFREE_EXPERT', 0)} | synth={c.get('SYNTHESIZE_CALIBRATED', 0)}"
-        )
-        self._plan_rows = plan["rows"]
-        self._refresh_table()
-        self._log(
-            f"Inspected {len(resolved)} shard(s): {plan['present_tensors']}/{plan['total_tensors']} present, "
-            f"{len(surv)} anchor layers, {len(miss)} layers to reconstruct via CheckFree."
-        )
-
-    def _refresh_table(self) -> None:
-        self.tree.delete(*self.tree.get_children())
-        f_act = self.filter_action_var.get()
-        q = self.search_var.get().strip().lower()
-        shown = 0
-        for idx, r in enumerate(self._plan_rows, 1):
-            if f_act != "ALL" and r["action"] != f_act:
-                continue
-            if q and q not in r["name"].lower() and q not in r["role"].lower():
-                continue
-            self.tree.insert(
-                "",
-                tk.END,
-                iid=r["name"],
-                values=(
-                    idx,
-                    r["name"],
-                    r["layer"],
-                    r["role"],
-                    r["shard"],
-                    r["action"],
-                    r["dtype"],
-                    "Planned",
-                ),
-            )
-            shown += 1
-            if shown >= 1500:
-                break
-
-    def _start_run(self) -> None:
-        if self._worker is not None and self._worker.is_alive():
-            return
-        mode = self.op_mode_var.get()
-        out = self.output_var.get().strip()
-        if mode != "fetch-hf" and not out:
-            messagebox.showwarning("SlimShard", "Please specify an output .safetensors path.")
-            return
-
-        self._stop_event.clear()
-        self._start_time = time.time()
-        self.progress_var.set(0.0)
-        self.run_btn.configure(state=tk.DISABLED)
-        self.stop_btn.configure(state=tk.NORMAL)
-
-        def progress_cb(done: int, total: int, tname: str, action: str, stats: dict) -> None:
-            self._queue.put(("progress", (done, total, tname, action, dict(stats))))
-
-        def worker() -> None:
-            try:
-                if mode == "recover":
-                    shard = self.shard_var.get().strip()
-                    idx = self.index_var.get().strip() or None
-                    cfg = self.config_var.get().strip() or None
-                    exp_dir = (
-                        self.export_dir_var.get().strip()
-                        if self.auto_bundle_var.get() and self.export_dir_var.get().strip()
-                        else None
-                    )
-                    try:
-                        tp = float(self.target_params_b_var.get())
-                    except Exception:
-                        tp = 0.0
-                    try:
-                        me = int(self.max_experts_var.get())
-                    except Exception:
-                        me = 0
-                    res = recover_from_shard(
-                        shard,
-                        idx,
-                        out,
-                        config=cfg,
-                        device=self.device_var.get(),
-                        verbose=False,
-                        progress_cb=progress_cb,
-                        stop_event=self._stop_event,
-                        export_hf_dir=exp_dir,
-                        target_params_b=tp if tp > 0.0 else None,
-                        max_experts=me if me > 0 else None,
-                        anchor_layers=self.anchor_layers_var.get().strip() or None,
-                    )
-                    if exp_dir:
-                        self._queue.put(("set_test_dir", exp_dir))
-                    self._queue.put(("done", ("CheckFree Recovery Complete", res)))
-                elif mode == "fetch-hf":
-                    url = self.hf_url_var.get().strip()
-                    mdir = self.model_dir_var.get().strip() or str(Path.cwd() / "hf_min_shards")
-                    try:
-                        tp = float(self.target_params_b_var.get())
-                    except Exception:
-                        tp = 0.0
-                    try:
-                        me = int(self.max_experts_var.get())
-                    except Exception:
-                        me = 0
-                    try:
-                        na = int(self.num_anchor_layers_var.get())
-                    except Exception:
-                        na = 3
-                    res = fetch_minimum_shards_from_hf(
-                        url,
-                        mdir,
-                        target_params_b=tp if tp > 0.0 else None,
-                        max_experts=me if me > 0 else None,
-                        num_anchor_layers=na,
-                        anchor_layers=self.anchor_layers_var.get().strip() or None,
-                        mode=self.hf_fetch_mode_var.get(),
-                        verbose=False,
-                        progress_cb=progress_cb,
-                        stop_event=self._stop_event,
-                    )
-                    self._queue.put(("hf_fetched", (mdir, res)))
-                    self._queue.put(("done", ("HF Minimum Shards Retrieved", res)))
-                elif mode == "build":
-                    mdir = self.model_dir_var.get().strip()
-                    cfg_obj = HPCConfig(device=self.device_var.get(), verbose=False).validate()
-                    res = build_slimshard(
-                        mdir,
-                        out,
-                        cfg=cfg_obj,
-                        quant_format=self.quant_format_var.get(),
-                        expert_keep_ratio=float(self.expert_keep_var.get()),
-                        verbose=False,
-                        progress_cb=progress_cb,
-                        stop_event=self._stop_event,
-                    )
-                    self._queue.put(("done", ("SlimShard Build Complete", res)))
-                elif mode == "export-gguf":
-                    shard = self.shard_var.get().strip()
-                    cfg = self.config_var.get().strip() or None
-                    fmt = self.quant_format_var.get()
-                    if fmt == "exact":
-                        fmt = "bf16"
-                    res = export_safetensors_to_gguf(
-                        shard,
-                        out,
-                        config=cfg,
-                        quant_format=fmt,
-                        device=self.device_var.get(),
-                        verbose=False,
-                        progress_cb=progress_cb,
-                        stop_event=self._stop_event,
-                    )
-                    self._queue.put(("done", ("GGUF Export Complete", res)))
-                else:
-                    shard = self.shard_var.get().strip()
-                    res = regenerate(
-                        shard,
-                        out,
-                        verbose=False,
-                        progress_cb=progress_cb,
-                        stop_event=self._stop_event,
-                    )
-                    self._queue.put(("done", ("SlimShard Regeneration Complete", res)))
-            except Exception as exc:
-                self._queue.put(("error", str(exc)))
-
-        self._worker = threading.Thread(target=worker, daemon=True)
-        self._worker.start()
-        self._log(f"Started {mode} -> {out}")
-
-    def _stop_run(self) -> None:
-        self._stop_event.set()
-        self._log("Cancellation requested...")
-
-    def _run_prompt_test(self) -> None:
-        mdir = self.test_model_dir_var.get().strip() or self.export_dir_var.get().strip()
-        if not mdir or not Path(mdir).exists():
-            messagebox.showwarning(
-                "Model Tester",
-                "Please specify a valid Recovered HF Model Directory first.",
-            )
-            return
-        prompt = self.test_prompt_var.get()
-        use_chat = bool(self.test_chat_mode_var.get())
-        max_new = int(self.test_max_tokens_var.get())
-
-        self.test_btn.configure(state=tk.DISABLED)
-        self.test_out_text.delete("1.0", tk.END)
-        self.test_out_text.insert(
-            tk.END, f"Loading {mdir} and running prompt {prompt!r}...\n"
-        )
-
-        def test_worker() -> None:
-            try:
-                import json
-                import torch
-                import torch.nn.functional as F
-                from safetensors.torch import safe_open
-                from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
-
-                t0 = time.time()
-                mpath = Path(mdir)
-                if mpath.is_file() and mpath.suffix == ".safetensors":
-                    st_file = mpath
-                    base_dir = mpath.parent
-                else:
-                    base_dir = mpath
-                    st_file = base_dir / "model.safetensors"
-                    if not st_file.exists():
-                        cands = sorted(base_dir.glob("*.safetensors"))
-                        if cands:
-                            st_file = cands[0]
-
-                cfg_file = base_dir / "config.json"
-                raw_cfg = json.loads(cfg_file.read_text()) if cfg_file.exists() else {}
-                if raw_cfg.get("model_type") == "deepseek_v41":
-                    decoded, out_list = run_deepseek_v41_generate(
-                        st_file,
-                        cfg_file,
-                        base_dir,
-                        prompt=prompt,
-                        max_new_tokens=max_new,
-                        use_chat_template=use_chat,
-                        device=self.device_var.get(),
-                    )
-                    dt_s = time.time() - t0
-                    self._queue.put(
-                        (
-                            "test_done",
-                            f"Completed in {dt_s:.2f}s:\n{decoded}\n\nToken IDs: {out_list}",
-                        )
-                    )
-                    return
-
-                tok = AutoTokenizer.from_pretrained(
-                    str(base_dir), trust_remote_code=True, local_files_only=True
-                )
-                cfg = AutoConfig.from_pretrained(
-                    str(base_dir), trust_remote_code=True, local_files_only=True
-                )
-                dev = "cuda:0" if torch.cuda.is_available() else "cpu"
-
-                # Fast on-demand expert streaming for MXFP8 MoE models, or standard load for generic models
-                q_cfg = getattr(cfg, "quantization_config", None) or {}
-                is_mxfp8 = (
-                    isinstance(q_cfg, dict) and q_cfg.get("quant_method") == "mxfp8"
-                ) or getattr(q_cfg, "quant_method", None) == "mxfp8"
-
-                if is_mxfp8 and st_file.exists():
-                    with torch.device("meta"):
-                        model = AutoModelForCausalLM.from_config(
-                            cfg, trust_remote_code=True, dtype=torch.bfloat16
-                        )
-                    sf = safe_open(str(st_file), framework="pt", device="cpu")
-                    for name, _ in list(model.named_parameters()):
-                        if ".moe.experts." in name:
-                            continue
-                        parts = name.split(".")
-                        mod = model
-                        for p in parts[:-1]:
-                            mod = getattr(mod, p)
-                        t = sf.get_tensor(name).to(device=dev)
-                        if t.dtype == torch.float32 and "e_score_correction_bias" not in name:
-                            t = t.to(torch.bfloat16)
-                        setattr(mod, parts[-1], torch.nn.Parameter(t, requires_grad=False))
-
-                    moe_layer = next(
-                        (l for l in model.model.layers if getattr(l, "is_moe", False)),
-                        None,
-                    )
-                    if moe_layer is not None:
-                        mod_cls = type(moe_layer.moe)
-                        raon_mod = __import__(
-                            mod_cls.__module__, fromlist=["dequantize_mxfp8", "situ_glu"]
-                        )
-                        dequantize_mxfp8 = raon_mod.dequantize_mxfp8
-                        situ_glu = raon_mod.situ_glu
-                        for lidx, layer in enumerate(model.model.layers):
-                            if getattr(layer, "is_moe", False):
-                                layer.moe._layer_idx = lidx
-
-                        def fast_moe_forward(self_moe, hidden: torch.Tensor) -> torch.Tensor:
-                            batch, seq, dim = hidden.shape
-                            flat = hidden.reshape(-1, dim)
-                            top, probs = self_moe.gate(flat)
-                            out = torch.zeros(
-                                flat.shape[0], dim, dtype=torch.float32, device=flat.device
-                            )
-                            hit = torch.bincount(
-                                top.flatten(), minlength=self_moe.num_experts
-                            )
-                            prefix = f"model.layers.{self_moe._layer_idx}.moe.experts"
-                            for expert_idx in hit.nonzero().flatten().tolist():
-                                rows, slot = torch.where(top == expert_idx)
-                                x = flat.index_select(0, rows)
-                                ep = f"{prefix}.{expert_idx}"
-                                gw = dequantize_mxfp8(
-                                    sf.get_tensor(f"{ep}.gate_proj.weight").to(dev, non_blocking=True),
-                                    sf.get_tensor(f"{ep}.gate_proj.weight_scale_inv").to(dev, non_blocking=True),
-                                    x.dtype,
-                                )
-                                uw = dequantize_mxfp8(
-                                    sf.get_tensor(f"{ep}.up_proj.weight").to(dev, non_blocking=True),
-                                    sf.get_tensor(f"{ep}.up_proj.weight_scale_inv").to(dev, non_blocking=True),
-                                    x.dtype,
-                                )
-                                dw = dequantize_mxfp8(
-                                    sf.get_tensor(f"{ep}.down_proj.weight").to(dev, non_blocking=True),
-                                    sf.get_tensor(f"{ep}.down_proj.weight_scale_inv").to(dev, non_blocking=True),
-                                    x.dtype,
-                                )
-                                act = situ_glu(
-                                    F.linear(x, gw),
-                                    F.linear(x, uw),
-                                    self_moe.gate_beta,
-                                    self_moe.value_beta,
-                                ).to(x.dtype)
-                                out.index_add_(
-                                    0,
-                                    rows,
-                                    F.linear(act, dw).float()
-                                    * probs[rows, slot].unsqueeze(-1),
-                                )
-                            out = out.to(hidden.dtype)
-                            if self_moe.shared_experts is not None:
-                                out = out + self_moe.shared_experts(flat)
-                            return out.reshape(batch, seq, dim)
-
-                        mod_cls.forward = fast_moe_forward
-                else:
-                    model = AutoModelForCausalLM.from_pretrained(
-                        mdir,
-                        trust_remote_code=True,
-                        local_files_only=True,
-                        dtype="auto",
-                        device_map="auto",
-                    )
-
-                model.eval()
-                with torch.no_grad():
-                    if use_chat and getattr(tok, "chat_template", None):
-                        inputs = tok.apply_chat_template(
-                            [{"role": "user", "content": prompt}],
-                            add_generation_prompt=True,
-                            tokenize=True,
-                            return_dict=True,
-                            return_tensors="pt",
-                            enable_thinking=False,
-                        ).to(dev)
-                        in_len = inputs["input_ids"].shape[-1]
-                        out_ids = model.generate(
-                            **inputs,
-                            max_new_tokens=max_new,
-                            do_sample=False,
-                            use_cache=True,
-                            pad_token_id=tok.eos_token_id,
-                        )
-                        decoded = tok.decode(out_ids[0][in_len:], skip_special_tokens=False)
-                    else:
-                        ids = tok(prompt, return_tensors="pt")["input_ids"].to(dev)
-                        out_ids = model.generate(
-                            ids,
-                            max_new_tokens=max_new,
-                            do_sample=False,
-                            use_cache=True,
-                            pad_token_id=tok.eos_token_id,
-                        )
-                        decoded = tok.decode(out_ids[0], skip_special_tokens=False)
-
-                dt_s = time.time() - t0
-                self._queue.put(
-                    (
-                        "test_done",
-                        f"Completed in {dt_s:.2f}s:\n{decoded}\n\nToken IDs: {out_ids[0].tolist()}",
-                    )
-                )
-            except Exception as exc:
-                self._queue.put(("test_done", f"Error: {exc}"))
-
-        threading.Thread(target=test_worker, daemon=True).start()
-
-    def _poll_queue(self) -> None:
-        try:
-            while True:
-                kind, payload = self._queue.get_nowait()
-                if kind == "progress":
-                    done, total, tname, action, stats = payload
-                    pct = 100.0 * float(done) / float(max(total, 1))
-                    self.progress_var.set(pct)
-                    self.tele_tensor_var.set(tname)
-                    self.tele_action_var.set(action)
-                    self.tele_progress_text_var.set(f"{done} / {total} ({pct:.1f}%)")
-                    elapsed = max(time.time() - (self._start_time or time.time()), 1.0e-3)
-                    rate = float(done) / elapsed
-                    eta = float(max(total - done, 0)) / max(rate, 1.0e-6)
-                    self.tele_speed_var.set(f"{rate:.1f} ten/s (ETA {_fmt_eta(eta)})")
-                    self.tele_elapsed_var.set(_fmt_eta(elapsed))
-                    if "present" in stats:
-                        self.tele_breakdown_var.set(
-                            f"present={stats.get('present', 0)} | "
-                            f"layer_interp={stats.get('checkfree_interpolated', 0)} | "
-                            f"expert_interp={stats.get('expert_interpolated', 0)} | "
-                            f"synth={stats.get('synthesized', 0)}"
-                        )
-                    if self.tree.exists(tname):
-                        vals = list(self.tree.item(tname, "values"))
-                        vals[-1] = "Done"
-                        self.tree.item(tname, values=vals)
-                elif kind == "set_test_dir":
-                    self.test_model_dir_var.set(str(payload))
-                elif kind == "hf_fetched":
-                    mdir, res = payload
-                    sh_paths = res.get("shard_paths", [])
-                    if sh_paths:
-                        self._set_shard_and_companions(Path(sh_paths[0]))
-                        self.shard_var.set(", ".join(str(p) for p in sh_paths))
-                    self.op_mode_var.set("recover")
-                    self._inspect_plan()
-                elif kind == "done":
-                    title, stats = payload
-                    elapsed = time.time() - (self._start_time or time.time())
-                    self.progress_var.set(100.0)
-                    self.tele_action_var.set("Completed")
-                    self.tele_elapsed_var.set(_fmt_eta(elapsed))
-                    self.run_btn.configure(state=tk.NORMAL)
-                    self.stop_btn.configure(state=tk.DISABLED)
-                    self._log(f"{title} in {_fmt_eta(elapsed)}: {stats}")
-                elif kind == "error":
-                    self.tele_action_var.set("Error / Stopped")
-                    self.run_btn.configure(state=tk.NORMAL)
-                    self.stop_btn.configure(state=tk.DISABLED)
-                    self._log(f"ERROR: {payload}")
-                    messagebox.showerror("SlimShard Error", str(payload))
-                elif kind == "test_done":
-                    self.test_btn.configure(state=tk.NORMAL)
-                    self.test_out_text.delete("1.0", tk.END)
-                    self.test_out_text.insert(tk.END, str(payload))
-                    self._log("Prompt evaluation finished.")
-        except queue.Empty:
-            pass
-        self.root.after(80, self._poll_queue)
-
-
-def launch_slimshard_gui(parent: tk.Tk | None = None) -> SlimShardGUI:
-    if parent is not None:
-        win = tk.Toplevel(parent)
-        return SlimShardGUI(win)
-    root = tk.Tk()
-    app = SlimShardGUI(root)
-    root.mainloop()
-    return app
-
-
-if __name__ == "__main__":
-    launch_slimshard_gui()