Upload gui.py

gui.py

@@ -7,16 +7,19 @@ Launch::
 
 Provides:
 * Source GGUF, iMatrix (.gguf / .dat), and Output (.gguf / .npz) file pickers
-* Interactive GGUF tensor table with Q2_K eligibility & iMatrix match status
+* Interactive GGUF tensor table with live per-tensor status & RMSE updates
+* Real-time Telemetry Dashboard showing active tensor, current pipeline phase,
+  dual progress bars (overall model + intra-tensor superblocks), throughput
+  (blk/s), ETA, running RMSE, RMSE/sigma, Boltzmann temperature, and floor hits
 * Full HPCConfig controls (Geometry-Preserving Analogs, Coupled Bilinear Q2_K,
   Sieve + 36-state Viterbi, Spectral/Vesica/DC shaping, Candidate lattice size)
-* Live CLI command preview with one-click copy
-* Threaded execution with per-tensor progress bar, live log, and cancellation
+* Timestamped verbose log stream with selectable verbosity level
 """
 
 from __future__ import annotations
 
 import argparse
+import datetime as dt
 import queue
 import shlex
 import threading
@@ -40,25 +43,31 @@ from hpc_quantize_v2.gguf import is_q2k_eligible, write_quantized_gguf
 from hpc_quantize_v2.reference import reference_solve, synthetic_cases
 
 
+def _ts() -> str:
+    return dt.datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+
 class HPCQuantizeGUI:
     def __init__(self, root: tk.Tk) -> None:
         self.root = root
         self.root.title("HPC-Quantize V2 — Factored Q2_K & Geometry-Preserving Analog Engine")
-        self.root.geometry("1180x820")
-        self.root.minsize(980, 680)
+        self.root.geometry("1260x900")
+        self.root.minsize(1040, 740)
 
         self._log_queue: queue.Queue[tuple[str, object]] = queue.Queue()
         self._stop_event = threading.Event()
         self._worker: threading.Thread | None = None
         self._reader: GGUFReader | None = None
         self._imatrix: dict[str, np.ndarray] | None = None
+        self._start_time: float | None = None
+        self._last_logged_phase: str = ""
 
         self._init_vars()
         self._apply_theme()
         self._build_layout()
         self._auto_populate_defaults()
         self._update_cli_preview()
-        self.root.after(100, self._poll_queue)
+        self.root.after(80, self._poll_queue)
 
     def _init_vars(self) -> None:
         self.gguf_var = tk.StringVar()
@@ -66,6 +75,7 @@ class HPCQuantizeGUI:
         self.output_var = tk.StringVar()
         self.mode_var = tk.StringVar(value="all")
         self.filter_var = tk.StringVar()
+        self.log_level_var = tk.StringVar(value="ultra")
 
         self.optimizer_var = tk.StringVar(value="hpc")
         self.cand_d_var = tk.IntVar(value=6)
@@ -91,7 +101,18 @@ class HPCQuantizeGUI:
 
         self.cli_preview_var = tk.StringVar()
         self.status_var = tk.StringVar(value="Ready.")
-        self.progress_var = tk.DoubleVar(value=0.0)
+        self.model_progress_var = tk.DoubleVar(value=0.0)
+        self.tensor_progress_var = tk.DoubleVar(value=0.0)
+
+        # Live telemetry variables
+        self.tele_tensor_var = tk.StringVar(value="Idle")
+        self.tele_phase_var = tk.StringVar(value="Waiting to start")
+        self.tele_blocks_var = tk.StringVar(value="0 / 0")
+        self.tele_speed_var = tk.StringVar(value="0.0 blk/s (ETA --)")
+        self.tele_rmse_var = tk.StringVar(value="--")
+        self.tele_temp_var = tk.StringVar(value="--")
+        self.tele_floors_var = tk.StringVar(value="cand=0, factor=0")
+        self.tele_elapsed_var = tk.StringVar(value="0.0s")
 
         for v in (
             self.gguf_var,
@@ -120,6 +141,8 @@ class HPCQuantizeGUI:
         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))
@@ -130,7 +153,7 @@ class HPCQuantizeGUI:
             background=panel,
             fieldbackground=panel,
             foreground=fg,
-            rowheight=24,
+            rowheight=23,
         )
         style.configure("Treeview.Heading", background="#262f3f", foreground=fg, font=("Sans", 9, "bold"))
         style.map("Treeview", background=[("selected", accent)])
@@ -140,27 +163,27 @@ class HPCQuantizeGUI:
         main.pack(fill=tk.BOTH, expand=True)
 
         # 1. File Selection Frame
-        files_frame = ttk.LabelFrame(main, text="1. GGUF & iMatrix Paths", padding=10)
-        files_frame.pack(fill=tk.X, pady=(0, 8))
+        files_frame = ttk.LabelFrame(main, text="1. GGUF & iMatrix Paths", padding=8)
+        files_frame.pack(fill=tk.X, pady=(0, 6))
         files_frame.columnconfigure(1, weight=1)
 
-        ttk.Label(files_frame, text="Source GGUF:").grid(row=0, column=0, sticky=tk.W, padx=(0, 8), pady=3)
-        ttk.Entry(files_frame, textvariable=self.gguf_var).grid(row=0, column=1, sticky=tk.EW, pady=3)
-        ttk.Button(files_frame, text="Browse...", command=self._browse_gguf).grid(row=0, column=2, padx=4, pady=3)
-        ttk.Button(files_frame, text="Inspect GGUF", command=self.inspect_files).grid(row=0, column=3, pady=3)
+        ttk.Label(files_frame, text="Source GGUF:").grid(row=0, column=0, sticky=tk.W, padx=(0, 8), pady=2)
+        ttk.Entry(files_frame, textvariable=self.gguf_var).grid(row=0, column=1, sticky=tk.EW, pady=2)
+        ttk.Button(files_frame, text="Browse...", command=self._browse_gguf).grid(row=0, column=2, padx=4, pady=2)
+        ttk.Button(files_frame, text="Inspect GGUF", command=self.inspect_files).grid(row=0, column=3, pady=2)
 
-        ttk.Label(files_frame, text="iMatrix (.gguf/.dat):").grid(row=1, column=0, sticky=tk.W, padx=(0, 8), pady=3)
-        ttk.Entry(files_frame, textvariable=self.imatrix_var).grid(row=1, column=1, sticky=tk.EW, pady=3)
-        ttk.Button(files_frame, text="Browse...", command=self._browse_imatrix).grid(row=1, column=2, padx=4, pady=3)
-        ttk.Button(files_frame, text="Clear", command=lambda: self.imatrix_var.set("")).grid(row=1, column=3, pady=3)
+        ttk.Label(files_frame, text="iMatrix (.gguf/.dat):").grid(row=1, column=0, sticky=tk.W, padx=(0, 8), pady=2)
+        ttk.Entry(files_frame, textvariable=self.imatrix_var).grid(row=1, column=1, sticky=tk.EW, pady=2)
+        ttk.Button(files_frame, text="Browse...", command=self._browse_imatrix).grid(row=1, column=2, padx=4, pady=2)
+        ttk.Button(files_frame, text="Clear", command=lambda: self.imatrix_var.set("")).grid(row=1, column=3, pady=2)
 
-        ttk.Label(files_frame, text="Output (.gguf/.npz):").grid(row=2, column=0, sticky=tk.W, padx=(0, 8), pady=3)
-        ttk.Entry(files_frame, textvariable=self.output_var).grid(row=2, column=1, sticky=tk.EW, pady=3)
-        ttk.Button(files_frame, text="Save As...", command=self._browse_output).grid(row=2, column=2, padx=4, pady=3)
+        ttk.Label(files_frame, text="Output (.gguf/.npz):").grid(row=2, column=0, sticky=tk.W, padx=(0, 8), pady=2)
+        ttk.Entry(files_frame, textvariable=self.output_var).grid(row=2, column=1, sticky=tk.EW, pady=2)
+        ttk.Button(files_frame, text="Save As...", command=self._browse_output).grid(row=2, column=2, padx=4, pady=2)
 
         # 2. Middle Split: Left = Settings, Right = Tensor Browser
         mid = ttk.PanedWindow(main, orient=tk.HORIZONTAL)
-        mid.pack(fill=tk.BOTH, expand=True, pady=(0, 8))
+        mid.pack(fill=tk.BOTH, expand=True, pady=(0, 6))
 
         left_pane = ttk.Frame(mid)
         right_pane = ttk.Frame(mid)
@@ -168,11 +191,11 @@ class HPCQuantizeGUI:
         mid.add(right_pane, weight=3)
 
         # Left: Engine & Factorization Options
-        opt_frame = ttk.LabelFrame(left_pane, text="2. Factored Q2_K & Analog Controls", padding=10)
+        opt_frame = ttk.LabelFrame(left_pane, text="2. Factored Q2_K & Analog Controls", padding=8)
         opt_frame.pack(fill=tk.BOTH, expand=True, padx=(0, 6))
 
         mode_row = ttk.Frame(opt_frame)
-        mode_row.pack(fill=tk.X, pady=(0, 6))
+        mode_row.pack(fill=tk.X, pady=(0, 4))
         ttk.Label(mode_row, text="Target Scope:").pack(side=tk.LEFT, padx=(0, 8))
         ttk.Radiobutton(
             mode_row, text="All Q2_K-Eligible Tensors", variable=self.mode_var, value="all"
@@ -182,7 +205,7 @@ class HPCQuantizeGUI:
         ).pack(side=tk.LEFT, padx=4)
 
         opt_row = ttk.Frame(opt_frame)
-        opt_row.pack(fill=tk.X, pady=(0, 6))
+        opt_row.pack(fill=tk.X, pady=(0, 4))
         ttk.Label(opt_row, text="Global Optimizer:").pack(side=tk.LEFT, padx=(0, 8))
         ttk.Radiobutton(
             opt_row, text="HPC (Sieve + 36-State Viterbi)", variable=self.optimizer_var, value="hpc"
@@ -192,40 +215,40 @@ class HPCQuantizeGUI:
         ).pack(side=tk.LEFT, padx=4)
 
         checks = ttk.Frame(opt_frame)
-        checks.pack(fill=tk.X, pady=4)
+        checks.pack(fill=tk.X, pady=2)
         ttk.Checkbutton(
             checks,
             text="Geometry-Preserving Weight Analogs (Iso-Moment + Vesica Gram + Subscale Lattice)",
             variable=self.use_analogs_var,
-        ).pack(anchor=tk.W, pady=2)
+        ).pack(anchor=tk.W, pady=1)
         ttk.Checkbutton(
             checks,
             text="Coupled Orthogonal-Basis Bilinear Q2_K Factorization",
             variable=self.coupled_q2k_var,
-        ).pack(anchor=tk.W, pady=2)
+        ).pack(anchor=tk.W, pady=1)
         ttk.Checkbutton(
             checks,
             text="Exact Joint (Ls, Lm) 16x16 Sub-block Scan",
             variable=self.joint_subscales_var,
-        ).pack(anchor=tk.W, pady=2)
+        ).pack(anchor=tk.W, pady=1)
         ttk.Checkbutton(
             checks,
             text="Spectral Fold / Vesica / DC Objective Penalty",
             variable=self.use_spectral_var,
-        ).pack(anchor=tk.W, pady=2)
+        ).pack(anchor=tk.W, pady=1)
         ttk.Checkbutton(
             checks,
             text="Sub-block 6-State Sieve & Rolling DC Residual Carry",
             variable=self.subblock_sieve_var,
-        ).pack(anchor=tk.W, pady=2)
+        ).pack(anchor=tk.W, pady=1)
         ttk.Checkbutton(
             checks,
             text="Local-Safety Candidate & Factored Floors (Monotone Bound)",
             variable=self.factor_floor_var,
-        ).pack(anchor=tk.W, pady=2)
+        ).pack(anchor=tk.W, pady=1)
 
         grid_f = ttk.Frame(opt_frame)
-        grid_f.pack(fill=tk.X, pady=6)
+        grid_f.pack(fill=tk.X, pady=4)
         for col in range(4):
             grid_f.columnconfigure(col, weight=1)
 
@@ -237,7 +260,7 @@ class HPCQuantizeGUI:
         self._spin_pair(grid_f, 2, 2, "Tensor Limit (0=all):", self.limit_var, 0, 9999)
 
         spec_f = ttk.LabelFrame(opt_frame, text="Spectral & DC Parameters", padding=6)
-        spec_f.pack(fill=tk.X, pady=4)
+        spec_f.pack(fill=tk.X, pady=2)
         for col in range(4):
             spec_f.columnconfigure(col, weight=1)
         ttk.Label(spec_f, text="DC Lambda:").grid(row=0, column=0, sticky=tk.W, padx=4, pady=2)
@@ -250,7 +273,7 @@ class HPCQuantizeGUI:
         ttk.Entry(spec_f, textvariable=self.sse_budget_var, width=8).grid(row=1, column=3, sticky=tk.EW, padx=4, pady=2)
 
         # Right: GGUF Tensor Browser
-        browser_frame = ttk.LabelFrame(right_pane, text="3. GGUF Tensor Inspector", padding=10)
+        browser_frame = ttk.LabelFrame(right_pane, text="3. GGUF Tensor Inspector & Live Status", padding=8)
         browser_frame.pack(fill=tk.BOTH, expand=True)
 
         search_row = ttk.Frame(browser_frame)
@@ -263,7 +286,7 @@ class HPCQuantizeGUI:
             search_row, text="Select Eligible", command=self._select_all_eligible
         ).pack(side=tk.LEFT, padx=4)
 
-        cols = ("name", "type", "dims", "row", "q2k", "imat")
+        cols = ("name", "type", "dims", "row", "q2k", "imat", "state")
         self.tree = ttk.Treeview(browser_frame, columns=cols, show="headings", selectmode="extended")
         self.tree.heading("name", text="Tensor Name")
         self.tree.heading("type", text="Type")
@@ -271,13 +294,15 @@ class HPCQuantizeGUI:
         self.tree.heading("row", text="Row Width")
         self.tree.heading("q2k", text="Q2_K")
         self.tree.heading("imat", text="iMatrix")
-
-        self.tree.column("name", width=250, anchor=tk.W)
-        self.tree.column("type", width=60, anchor=tk.CENTER)
-        self.tree.column("dims", width=110, anchor=tk.CENTER)
-        self.tree.column("row", width=75, anchor=tk.E)
-        self.tree.column("q2k", width=55, anchor=tk.CENTER)
-        self.tree.column("imat", width=65, anchor=tk.CENTER)
+        self.tree.heading("state", text="Live Status / RMSE")
+
+        self.tree.column("name", width=220, anchor=tk.W)
+        self.tree.column("type", width=52, anchor=tk.CENTER)
+        self.tree.column("dims", width=105, anchor=tk.CENTER)
+        self.tree.column("row", width=70, anchor=tk.E)
+        self.tree.column("q2k", width=48, anchor=tk.CENTER)
+        self.tree.column("imat", width=56, anchor=tk.CENTER)
+        self.tree.column("state", width=165, anchor=tk.W)
         self.tree.bind("<<TreeviewSelect>>", lambda _e: self._update_cli_preview())
 
         tree_scroll = ttk.Scrollbar(browser_frame, orient=tk.VERTICAL, command=self.tree.yview)
@@ -286,16 +311,50 @@ class HPCQuantizeGUI:
         tree_scroll.pack(side=tk.RIGHT, fill=tk.Y)
 
         # 4. Equivalent CLI Command Preview
-        cli_frame = ttk.LabelFrame(main, text="4. Equivalent Terminal Command", padding=8)
-        cli_frame.pack(fill=tk.X, pady=(0, 8))
+        cli_frame = ttk.LabelFrame(main, text="4. Equivalent Terminal Command", padding=6)
+        cli_frame.pack(fill=tk.X, pady=(0, 6))
         ttk.Entry(cli_frame, textvariable=self.cli_preview_var, state="readonly").pack(
             side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 6)
         )
         ttk.Button(cli_frame, text="Copy Command", command=self._copy_cli).pack(side=tk.RIGHT)
 
-        # 5. Action Buttons + Progress + Log Console
-        bottom = ttk.LabelFrame(main, text="5. Execution & Live Output", padding=8)
-        bottom.pack(fill=tk.BOTH, expand=False)
+        # 5. Live Telemetry Dashboard + Execution + Verbose Console
+        bottom = ttk.LabelFrame(main, text="5. Live Telemetry Dashboard & Verbose Execution Stream", padding=8)
+        bottom.pack(fill=tk.BOTH, expand=True)
+
+        tele = ttk.Frame(bottom)
+        tele.pack(fill=tk.X, pady=(0, 6))
+        for col in (1, 3, 5, 7):
+            tele.columnconfigure(col, weight=1)
+
+        ttk.Label(tele, text="Active Tensor:", style="TeleKey.TLabel").grid(row=0, column=0, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, textvariable=self.tele_tensor_var, style="TeleVal.TLabel").grid(
+            row=0, column=1, columnspan=3, sticky=tk.W, padx=4, pady=1
+        )
+        ttk.Label(tele, text="Current Stage:", style="TeleKey.TLabel").grid(row=0, column=4, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, textvariable=self.tele_phase_var, style="TeleVal.TLabel").grid(
+            row=0, column=5, columnspan=3, sticky=tk.W, padx=4, pady=1
+        )
+
+        ttk.Label(tele, text="Superblocks:", style="TeleKey.TLabel").grid(row=1, column=0, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, textvariable=self.tele_blocks_var, style="TeleVal.TLabel").grid(row=1, column=1, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, text="Throughput:", style="TeleKey.TLabel").grid(row=1, column=2, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, textvariable=self.tele_speed_var, style="TeleVal.TLabel").grid(row=1, column=3, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, text="Running RMSE:", style="TeleKey.TLabel").grid(row=1, column=4, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, textvariable=self.tele_rmse_var, style="TeleVal.TLabel").grid(row=1, column=5, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, text="Sieve Temp / Floors:", style="TeleKey.TLabel").grid(row=1, column=6, sticky=tk.W, padx=4, pady=1)
+        ttk.Label(tele, textvariable=self.tele_floors_var, style="TeleVal.TLabel").grid(row=1, column=7, sticky=tk.W, padx=4, pady=1)
+
+        bars = ttk.Frame(bottom)
+        bars.pack(fill=tk.X, pady=(0, 6))
+        bars.columnconfigure(1, weight=1)
+        ttk.Label(bars, text="Model Progress:", style="TeleKey.TLabel").grid(row=0, column=0, sticky=tk.W, padx=(0, 6), pady=2)
+        self.model_progress = ttk.Progressbar(bars, variable=self.model_progress_var, maximum=100.0)
+        self.model_progress.grid(row=0, column=1, sticky=tk.EW, pady=2)
+
+        ttk.Label(bars, text="Tensor Blocks:", style="TeleKey.TLabel").grid(row=1, column=0, sticky=tk.W, padx=(0, 6), pady=2)
+        self.tensor_progress = ttk.Progressbar(bars, variable=self.tensor_progress_var, maximum=100.0)
+        self.tensor_progress.grid(row=1, column=1, sticky=tk.EW, pady=2)
 
         btn_row = ttk.Frame(bottom)
         btn_row.pack(fill=tk.X, pady=(0, 6))
@@ -310,22 +369,30 @@ class HPCQuantizeGUI:
         self.bench_btn = ttk.Button(
             btn_row, text="Run Solver Benchmark", command=self.start_benchmark
         )
-        self.bench_btn.pack(side=tk.LEFT, padx=(0, 12))
-        ttk.Label(btn_row, textvariable=self.status_var).pack(side=tk.LEFT, fill=tk.X, expand=True)
+        self.bench_btn.pack(side=tk.LEFT, padx=(0, 6))
+        ttk.Button(
+            btn_row, text="Clear Log", command=lambda: self.log_text.delete("1.0", tk.END)
+        ).pack(side=tk.LEFT, padx=(0, 12))
 
-        self.progress = ttk.Progressbar(bottom, variable=self.progress_var, maximum=100.0)
-        self.progress.pack(fill=tk.X, pady=(0, 6))
+        ttk.Label(btn_row, text="Log Verbosity:").pack(side=tk.LEFT, padx=(0, 4))
+        ttk.Radiobutton(
+            btn_row, text="Ultra-Verbose (Every Block Step)", variable=self.log_level_var, value="ultra"
+        ).pack(side=tk.LEFT, padx=2)
+        ttk.Radiobutton(
+            btn_row, text="Stage Transitions", variable=self.log_level_var, value="stages"
+        ).pack(side=tk.LEFT, padx=2)
+        ttk.Label(btn_row, textvariable=self.status_var).pack(side=tk.RIGHT, padx=4)
 
         log_frame = ttk.Frame(bottom)
         log_frame.pack(fill=tk.BOTH, expand=True)
         self.log_text = tk.Text(
             log_frame,
-            height=9,
+            height=11,
             bg="#0f131a",
             fg="#d1d5db",
             insertbackground="#ffffff",
             font=("Monospace", 9),
-            wrap=tk.WORD,
+            wrap=tk.NONE,
         )
         log_scroll = ttk.Scrollbar(log_frame, orient=tk.VERTICAL, command=self.log_text.yview)
         self.log_text.configure(yscrollcommand=log_scroll.set)
@@ -378,7 +445,7 @@ class HPCQuantizeGUI:
             self.output_var.set(path)
 
     def _log(self, msg: str) -> None:
-        self.log_text.insert(tk.END, msg + "\n")
+        self.log_text.insert(tk.END, f"[{_ts()}] {msg}\n")
         self.log_text.see(tk.END)
 
     def build_config(self) -> HPCConfig:
@@ -495,6 +562,7 @@ class HPCQuantizeGUI:
                     ti.row_width,
                     "Yes" if elig else "No",
                     "Yes" if has_imat else "-",
+                    "Pending (Q2_K)" if elig else "Passthrough",
                 ),
             )
 
@@ -514,7 +582,8 @@ class HPCQuantizeGUI:
     def stop_worker(self) -> None:
         if self._worker and self._worker.is_alive():
             self._stop_event.set()
-            self.status_var.set("Cancelling after current tensor...")
+            self.status_var.set("Stopping immediately...")
+            self._log("Cancel requested — halting active block loop...")
 
     def start_quantization(self) -> None:
         if self._worker and self._worker.is_alive():
@@ -543,11 +612,19 @@ class HPCQuantizeGUI:
         limit = int(self.limit_var.get())
 
         self._stop_event.clear()
-        self.progress_var.set(0.0)
+        self._start_time = time.time()
+        self._last_logged_phase = ""
+        self.model_progress_var.set(0.0)
+        self.tensor_progress_var.set(0.0)
         self.run_btn.configure(state=tk.DISABLED)
         self.bench_btn.configure(state=tk.DISABLED)
         self.stop_btn.configure(state=tk.NORMAL)
-        self.status_var.set("Running quantization...")
+        self.status_var.set("Starting quantization...")
+        self._log(
+            f"Starting quantization: source={Path(gguf_path).name} -> output={Path(out_path).name} "
+            f"(cand={cfg.n_cand_d}x{cfg.n_cand_m}, analogs={cfg.use_weight_analogs}, "
+            f"coupled={cfg.factor_coupled_q2k}, optimizer={cfg.optimizer.upper()})"
+        )
 
         self._worker = threading.Thread(
             target=self._quantize_worker,
@@ -569,20 +646,28 @@ class HPCQuantizeGUI:
         try:
             imat = None
             if imat_path and Path(imat_path).exists():
+                self._log_queue.put(("log", f"Loading iMatrix from {imat_path} ..."))
                 imat = read_imatrix(imat_path)
-                self._log_queue.put(("log", f"Loaded iMatrix ({len(imat)} tensors) from {imat_path}"))
+                self._log_queue.put(("log", f"Loaded iMatrix: {len(imat)} tensor entries ready."))
 
             quantizer = Q2KQuantizer(cfg)
             if out_path.lower().endswith(".npz") and selected and len(selected) == 1:
                 reader = GGUFReader(gguf_path)
                 tname = next(iter(selected))
+                ti = reader.info(tname)
                 x, row = reader.read_tensor(tname)
                 imp = None
                 if imat is not None:
                     raw = lookup_imatrix(imat, tname)
                     if raw is not None:
                         imp = expand_importance(raw, x.size, row)
-                res = quantizer.quantize(x, importance=imp, row_width=row)
+                res = quantizer.quantize(
+                    x,
+                    importance=imp,
+                    row_width=row,
+                    status_callback=lambda ev: self._log_queue.put(("stage", (1, 1, ti, ev))),
+                    stop_event=self._stop_event,
+                )
                 np.savez_compressed(
                     out_path,
                     scales=res.scales,
@@ -596,16 +681,11 @@ class HPCQuantizeGUI:
                 )
                 return
 
+            def on_stage(idx: int, total: int, ti, ev: dict):
+                self._log_queue.put(("stage", (idx, total, ti, ev)))
+
             def on_progress(done: int, total: int, name: str, action: str, rmse: float | None, has_imat: bool):
-                pct = 100.0 * done / max(total, 1)
-                self._log_queue.put(("progress", (pct, f"[{done}/{total}] {action} {name}")))
-                if action == "Q2_K" and rmse is not None:
-                    self._log_queue.put(
-                        (
-                            "log",
-                            f"[{done}/{total}] Q2_K {name:44s} RMSE={rmse:.6e} iMatrix={'yes' if has_imat else 'no'}",
-                        )
-                    )
+                self._log_queue.put(("tensor_done", (done, total, name, action, rmse, has_imat)))
 
             stats = write_quantized_gguf(
                 gguf_path,
@@ -617,14 +697,15 @@ class HPCQuantizeGUI:
                 limit=limit,
                 verbose=False,
                 progress_callback=on_progress,
+                stage_callback=on_stage,
                 stop_event=self._stop_event,
             )
-            dt = time.time() - t0
+            dt_sec = time.time() - t0
             self._log_queue.put(
                 (
                     "done",
                     f"Wrote {out_path}: {int(stats['quantized'])}/{int(stats['tensors'])} tensors Q2_K, "
-                    f"overall RMSE={stats['rmse']:.6e} ({dt:.1f}s)",
+                    f"overall RMSE={stats['rmse']:.6e} ({dt_sec:.1f}s)",
                 )
             )
         except InterruptedError as exc:
@@ -641,7 +722,9 @@ class HPCQuantizeGUI:
             messagebox.showerror("Invalid Configuration", str(exc))
             return
         self._stop_event.clear()
-        self.progress_var.set(0.0)
+        self._start_time = time.time()
+        self.model_progress_var.set(0.0)
+        self.tensor_progress_var.set(0.0)
         self.run_btn.configure(state=tk.DISABLED)
         self.bench_btn.configure(state=tk.DISABLED)
         self.stop_btn.configure(state=tk.NORMAL)
@@ -662,10 +745,24 @@ class HPCQuantizeGUI:
                 w = np.ones(x.size, dtype=np.float32)
                 v2 = factor_only_solve(x, w, cfg)
                 ref_obj, _ = reference_solve(x, w, cfg, cfg.use_spectral)
-                gains[kind].append((ref_obj - v2.objective) / max(abs(ref_obj), 1.0e-30))
-                self._log_queue.put(("progress", (100.0 * idx / total, f"Bench {idx}/{total} ({kind})")))
+                gain_pct = (ref_obj - v2.objective) / max(abs(ref_obj), 1.0e-30) * 100.0
+                gains[kind].append(gain_pct / 100.0)
+                self._log_queue.put(
+                    (
+                        "bench_step",
+                        (
+                            idx,
+                            total,
+                            kind,
+                            f"Case {idx}/{total} [{kind}]: ref={ref_obj:.5e} -> V2={v2.objective:.5e} "
+                            f"(+{gain_pct:.2f}%, d={float(v2.d):.5f}, dmin={float(v2.dmin):.5f}, starts={v2.starts})",
+                        ),
+                    )
+                )
 
-            self._log_queue.put(("log", f"--- Benchmark (spectral={cfg.use_spectral}, analogs={cfg.use_weight_analogs}) ---"))
+            self._log_queue.put(
+                ("log", f"=== Summary (spectral={cfg.use_spectral}, analogs={cfg.use_weight_analogs}) ===")
+            )
             for kind, vals in gains.items():
                 arr = np.asarray(vals)
                 self._log_queue.put(
@@ -681,6 +778,16 @@ class HPCQuantizeGUI:
         except Exception as exc:
             self._log_queue.put(("error", str(exc)))
 
+    def _update_tree_row_state(self, name: str, state_text: str, focus: bool = False) -> None:
+        if not self.tree.exists(name):
+            return
+        vals = list(self.tree.item(name, "values"))
+        if len(vals) >= 7:
+            vals[6] = state_text
+            self.tree.item(name, values=vals)
+        if focus:
+            self.tree.see(name)
+
     def _poll_queue(self) -> None:
         while True:
             try:
@@ -689,20 +796,76 @@ class HPCQuantizeGUI:
                 break
             if kind == "log":
                 self._log(str(payload))
-            elif kind == "progress":
-                pct, msg = payload  # type: ignore[misc]
-                self.progress_var.set(float(pct))
-                self.status_var.set(str(msg))
+            elif kind == "stage":
+                idx, total, ti, ev = payload  # type: ignore[misc]
+                phase = ev.get("phase", "")
+                done = int(ev.get("done", 0))
+                tot_blk = max(int(ev.get("total", 1)), 1)
+                detail = ev.get("detail", "")
+                blk_pct = 100.0 * done / tot_blk
+                overall_pct = 100.0 * ((idx - 1) + (done / tot_blk)) / max(total, 1)
+
+                self.model_progress_var.set(overall_pct)
+                self.tensor_progress_var.set(blk_pct)
+                self.tele_tensor_var.set(f"[{idx}/{total}] {ti.name} ({ti.type_name}, dims={ti.dims})")
+                self.tele_phase_var.set(phase)
+                self.tele_blocks_var.set(f"{done:,} / {tot_blk:,} ({blk_pct:.1f}%)")
+
+                if "rate" in ev and "eta" in ev:
+                    self.tele_speed_var.set(f"{ev['rate']:.1f} blk/s (ETA {ev['eta']:.1f}s)")
+                if "rmse" in ev and "sigma" in ev:
+                    r, s = float(ev["rmse"]), float(ev["sigma"])
+                    self.tele_rmse_var.set(f"{r:.6e} (r/σ={r/max(s, 1e-15):.4f})")
+                if "temperature" in ev or "cand_floors" in ev:
+                    t_val = ev.get("temperature", 0.0)
+                    cf = ev.get("cand_floors", 0)
+                    ff = ev.get("fac_floors", 0)
+                    self.tele_floors_var.set(f"T={t_val:.2e} | cand={cf}, fac={ff}")
+
+                self.status_var.set(f"[{idx}/{total}] {ti.name} — {phase} ({blk_pct:.0f}%)")
+                self._update_tree_row_state(ti.name, f"{phase.split(':')[0]} ({blk_pct:.0f}%)", focus=True)
+
+                is_Copy = phase.startswith("Passthrough Copy")
+                phase_key = f"{ti.name}::{phase}"
+                if not is_Copy:
+                    if self.log_level_var.get() == "ultra" or phase_key != self._last_logged_phase:
+                        self._log(f"[{idx}/{total}] {ti.name} | {phase} | {detail}")
+                        self._last_logged_phase = phase_key
+            elif kind == "tensor_done":
+                done, total, name, action, rmse, has_imat = payload  # type: ignore[misc]
+                self.model_progress_var.set(100.0 * done / max(total, 1))
+                self.tensor_progress_var.set(100.0)
+                if action == "Q2_K" and rmse is not None:
+                    self._update_tree_row_state(name, f"Q2_K (RMSE={rmse:.4e})")
+                    self._log(
+                        f"[{done}/{total}] FINISHED {name:42s} -> Q2_K RMSE={rmse:.6e} (iMatrix={'yes' if has_imat else 'no'})"
+                    )
+                else:
+                    self._update_tree_row_state(name, "Copied verbatim")
+                    if self.log_level_var.get() == "ultra" or done % 25 == 0 or done == total:
+                        self._log(f"[{done}/{total}] COPIED   {name}")
+            elif kind == "bench_step":
+                idx, total, bkind, msg = payload  # type: ignore[misc]
+                pct = 100.0 * idx / max(total, 1)
+                self.model_progress_var.set(pct)
+                self.tensor_progress_var.set(pct)
+                self.tele_tensor_var.set(f"Synthetic Benchmark ({bkind})")
+                self.tele_phase_var.set(f"Block {idx}/{total}")
+                self.tele_blocks_var.set(f"{idx} / {total}")
+                self._log(str(msg))
             elif kind == "done":
-                self.progress_var.set(100.0)
+                self.model_progress_var.set(100.0)
+                self.tensor_progress_var.set(100.0)
+                self.tele_phase_var.set("Complete")
                 self.status_var.set(str(payload))
                 self._log(str(payload))
                 self._reset_buttons()
             elif kind in ("cancelled", "error"):
+                self.tele_phase_var.set(kind.upper())
                 self.status_var.set(f"{kind.upper()}: {payload}")
                 self._log(f"{kind.upper()}: {payload}")
                 self._reset_buttons()
-        self.root.after(100, self._poll_queue)
+        self.root.after(80, self._poll_queue)
 
     def _reset_buttons(self) -> None:
         self.run_btn.configure(state=tk.NORMAL)