minor bug fix and update quantized feature

app.py

@@ -111,7 +111,9 @@ from src.app_helpers.pipeline_table import (
     ROW_NUMBER_COL,
     add_row_numbers,
     auto_pipeline_datatypes,
+    embed_dl_icon_in_hf_model_cell,
     filter_auto_pipeline_table,
+    on_queue_dl_click,
     on_pipeline_dl_click,
     prepare_auto_pipeline_display_df,
 )
@@ -642,8 +644,15 @@ with demo:
                     f"Finished Quantizations ({len(finished_quant_queue_df)})",
                     open=False, elem_id="accordion-finished-quant",
                 ) as accordion_finished_quant:
+                    _finished_quant_display_df = (
+                        finished_quant_queue_df[QUANT_DISPLAY_COLS].copy()
+                        if not finished_quant_queue_df.empty
+                        else finished_quant_queue_df.copy()
+                    )
+                    if "model" in _finished_quant_display_df.columns:
+                        _finished_quant_display_df["model"] = _finished_quant_display_df["model"].map(embed_dl_icon_in_hf_model_cell)
                     finished_quant_table = gr.components.Dataframe(
-                        value=finished_quant_queue_df[QUANT_DISPLAY_COLS] if not finished_quant_queue_df.empty else finished_quant_queue_df,
+                        value=_finished_quant_display_df,
                         headers=QUANT_DISPLAY_HEADERS,
                         datatype=QUANT_DISPLAY_TYPES,
                         row_count=5,
@@ -970,6 +979,13 @@ with demo:
     _quant_submit_evt.then(fn=refresh_queue_tables, inputs=_REFRESH_INPUTS, outputs=_REFRESH_OUTPUTS)
     _eval_submit_evt.then(fn=refresh_queue_tables, inputs=_REFRESH_INPUTS, outputs=_REFRESH_OUTPUTS)
 
+    finished_quant_table.select(
+        on_queue_dl_click,
+        inputs=[],
+        outputs=[pipeline_dl_trigger],
+        queue=True,
+    )
+
 
     # Checkbox filters — instantly re-filter the queue tables
     my_submissions_quant_cb.change(
@@ -1079,8 +1095,8 @@ with demo:
         }""",
     )
 
-    # ── Live queue refresh (every 60 s, transparent to the user) ─────────
-    _queue_timer = gr.Timer(value=60)
+    # ── Live queue refresh (every 5 s so dispatcher status changes surface promptly) ─────────
+    _queue_timer = gr.Timer(value=5)
     _queue_timer.tick(
         fn=refresh_queue_tables,
         inputs=_REFRESH_INPUTS,
@@ -1097,7 +1113,8 @@ with demo:
         auto_pipeline_size_slider,
     ]
     _pipeline_refresh_outputs = [hidden_auto_pipeline_table, auto_pipeline_table]
-    _queue_timer.tick(
+    _pipeline_timer = gr.Timer(value=60)
+    _pipeline_timer.tick(
         fn=refresh_pipeline_leaderboard,
         inputs=_pipeline_refresh_inputs,
         outputs=_pipeline_refresh_outputs,

src/app_helpers/pipeline_table.py

@@ -68,20 +68,31 @@ def prepare_auto_pipeline_display_df(df: pd.DataFrame) -> pd.DataFrame:
     return display_df.fillna("")
 
 
-def _embed_dl_icon_in_quantized(row):
-    """Insert a download-icon span just before the ``</a>`` in the model link."""
-    try:
-        cell = str(row["Quantized Model"])
-    except Exception:
-        return row["Quantized Model"]
-    if not cell or not cell.strip():
-        return cell
+def _extract_hf_repo(value: str) -> str:
+    """Return an ``org/repo`` id from a Hugging Face link or markdown/html cell."""
+    cell = str(value or "")
+    hf_hash = re.search(r'#hf/([^\s"\'>/]+(?:/[^\s"\'>/]+)+)', cell)
+    if hf_hash:
+        return hf_hash.group(1).rstrip("/")
+
+    title_match = re.search(r'\btitle=["\']([^"\']+/[^"\']+)["\']', cell)
+    if title_match:
+        return title_match.group(1).strip().rstrip("/")
 
     hf_match = re.search(r'href=["\']https://huggingface\.co/([^"\'\/][^"\']*)["\' \\s]', cell)
     if hf_match:
-        artifact = hf_match.group(1).rstrip("/")
-    else:
-        artifact = re.sub(r"<[^>]+>", "", cell).strip()
+        return hf_match.group(1).rstrip("/")
+
+    plain = re.sub(r"<[^>]+>", "", cell).strip()
+    return plain.rstrip("/") if "/" in plain else ""
+
+
+def embed_dl_icon_in_hf_model_cell(cell: str) -> str:
+    """Insert a download-icon span into a Hugging Face model cell."""
+    if not cell or not str(cell).strip() or "dl-cell-link" in str(cell):
+        return cell
+
+    artifact = _extract_hf_repo(str(cell))
     if not artifact or "/" not in artifact:
         return cell
 
@@ -92,8 +103,17 @@ def _embed_dl_icon_in_quantized(row):
         f'color:#2563eb;font-size:11px;font-weight:700;line-height:16px;vertical-align:middle;'
         f'padding-bottom:1px;">↓</span>'
     )
-    new_cell = re.sub(r"</a>", icon_html + "</a>", cell, count=1)
-    return new_cell if new_cell != cell else cell + icon_html
+    new_cell = re.sub(r"</a>", icon_html + "</a>", str(cell), count=1)
+    return new_cell if new_cell != str(cell) else str(cell) + icon_html
+
+
+def _embed_dl_icon_in_quantized(row):
+    """Insert a download-icon span just before the ``</a>`` in the model link."""
+    try:
+        cell = str(row["Quantized Model"])
+    except Exception:
+        return row["Quantized Model"]
+    return embed_dl_icon_in_hf_model_cell(cell)
 
 
 def _search_auto_pipeline_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
@@ -203,16 +223,9 @@ def on_pipeline_dl_click(select_data: gr.SelectData, hidden_df: pd.DataFrame) ->
     if "dl-cell-link" not in cell_value and "#hf/" not in cell_value:
         return ""
 
-    hf_hash = re.search(r'#hf/([^\s"\'>/]+(?:/[^\s"\'>/]+)+)', cell_value)
-    if hf_hash:
-        artifact = hf_hash.group(1).rstrip("/")
-        if "/" in artifact:
-            return artifact
-    title_match = re.search(r'\btitle=["\']([^"\']+/[^"\']+)["\']', cell_value)
-    if title_match:
-        artifact = title_match.group(1).strip()
-        if "/" in artifact:
-            return artifact
+    artifact = _extract_hf_repo(cell_value)
+    if artifact and "/" in artifact:
+        return artifact
 
     # Last-resort fallback: look up by row index (may be wrong when sorted).
     row_idx = select_data.index[0]
@@ -229,3 +242,12 @@ def on_pipeline_dl_click(select_data: gr.SelectData, hidden_df: pd.DataFrame) ->
     except Exception:
         pass
     return ""
+
+
+def on_queue_dl_click(select_data: gr.SelectData) -> str:
+    """Return the repo id from a queue-table download icon click."""
+    cell_value = str(select_data.value or "")
+    if "dl-cell-link" not in cell_value and "#hf/" not in cell_value:
+        return ""
+    artifact = _extract_hf_repo(cell_value)
+    return artifact if artifact and "/" in artifact else ""

src/app_helpers/queues.py

@@ -7,7 +7,10 @@ import re
 import gradio as gr
 import pandas as pd
 
-from src.app_helpers.pipeline_table import filter_auto_pipeline_table
+from src.app_helpers.pipeline_table import (
+    embed_dl_icon_in_hf_model_cell,
+    filter_auto_pipeline_table,
+)
 from src.display.utils import (
     EVAL_COLS,
     EVAL_DISPLAY_COLS,
@@ -46,9 +49,12 @@ def refresh_queue_tables(
             return df[df["submitted_by"] == username].reset_index(drop=True)
         return df
 
-    def _quant_display(df):
+    def _quant_display(df, with_download_icon=False):
         cols = [c for c in QUANT_DISPLAY_COLS if c in df.columns]
-        return df[cols] if cols else df
+        out = df[cols].copy() if cols else df.copy()
+        if with_download_icon and "model" in out.columns:
+            out["model"] = out["model"].map(embed_dl_icon_in_hf_model_cell)
+        return out
 
     def _eval_display(df):
         cols = [c for c in EVAL_DISPLAY_COLS if c in df.columns]
@@ -76,7 +82,7 @@ def refresh_queue_tables(
     fail_e = _search_queue_df(_filt(new_failed_eval,   show_mine_eval), query_eval)
 
     return (
-        _quant_display(fin_q),
+        _quant_display(fin_q, with_download_icon=True),
         _quant_display(run_q),
         _quant_display(pen_q),
         _quant_display(fail_q),

src/app_helpers/submissions.py

@@ -211,6 +211,7 @@ def submit_model(
             hardware_override=hw_override,
             gpu_count_override=count_override,
             submitted_by=username,
+            submitted_orgs=orgs,
             user_token=oauth_token.token if oauth_token else None,
         )
     )
@@ -278,6 +279,7 @@ def submit_quant(
             hardware_override=hw_override,
             gpu_count_override=count_override,
             submitted_by=username,
+            submitted_orgs=orgs,
             user_token=oauth_token.token if oauth_token else None,
         )
     )

src/ci_dispatcher.py

@@ -13,15 +13,24 @@ Concurrency control:
       ``max_instances=1`` + ``coalesce=True`` prevent overlapping scans.
 
 Active status reconciliation:
-    Each scan cycle queries the Azure DevOps Runs API for entries that have a
-    ``ci_run_id``.  The real pipeline state is mapped back to local status.
+    Every scan cycle queries the Azure DevOps Runs API for entries that have a
+    ``ci_run_id`` (independent of ``enable_retry`` so the UI always reflects the
+    real pipeline state).  The real pipeline state is mapped back to local
+    status.  How a *failure* resolves depends on ``enable_retry``:
+
+    * ``enable_retry=True``  → failures reset to ``Pending`` (re-dispatched),
+      up to ``_MAX_RETRIES`` then ``Failed``.
+    * ``enable_retry=False`` → failures map to a terminal failed status
+      (``Quant Failed`` / ``Eval Failed``) shown immediately in the UI; the
+      entry is not re-dispatched.
+
     Time-based guards cover ALL failure modes:
 
-    1. Azure ``completed+failed/canceled`` → retry (immediate)
-    2. Azure ``completed+succeeded`` but no write-back after grace period → retry
-    3. Azure ``inProgress`` beyond max runtime → retry (pipeline hung)
-    4. Azure API unreachable beyond fallback timeout → retry
-    5. All retries go through ``_MAX_RETRIES`` limit → ``Failed``
+    1. Azure ``completed+failed/canceled`` → resolve failure (immediate)
+    2. Azure ``completed+succeeded`` but no write-back after grace period → resolve failure
+    3. Azure ``inProgress`` beyond max runtime → resolve failure (pipeline hung)
+    4. Azure API unreachable beyond fallback timeout → resolve failure
+    5. With retry enabled, all resets go through ``_MAX_RETRIES`` limit → ``Failed``
 """
 
 import base64
@@ -104,7 +113,8 @@ class CIDispatcher:
         if not self._enable_retry:
             logger.info(
                 "CIDispatcher: automatic retry is DISABLED. "
-                "Failed runs will NOT be reset to Pending."
+                "Azure failures are reconciled to a terminal failed status "
+                "(Quant Failed / Eval Failed) instead of being re-dispatched."
             )
 
     # ── public entry point (called by APScheduler) ───────────────────────
@@ -124,11 +134,12 @@ class CIDispatcher:
             logger.error("[dispatcher] Repo sync failed, skipping cycle", exc_info=True)
             return
 
-        # 2) Reconcile active entries against Azure real status (only if retry enabled)
-        if self._enable_retry:
-            self._reconcile_active_runs()
-        else:
-            logger.debug("[dispatcher] retry disabled — skipping reconcile")
+        # 2) Reconcile active entries against Azure real status.
+        #    Always runs (even with retry disabled) so the UI reflects the real
+        #    Azure outcome.  ``enable_retry`` only controls what a *failure*
+        #    resolves to: a Pending re-dispatch (retry) vs a terminal failed
+        #    status (no retry).  See ``_resolve_failure``.
+        self._reconcile_active_runs()
 
         # 3) Collect status summary for logging
         running_models, triggered_models, pending_models = self._collect_status_summary()
@@ -402,7 +413,7 @@ class CIDispatcher:
             # ── No ci_run_id (e.g. Triggered but API call never returned) ──
             if not run_id:
                 if triggered_at and self._hours_since(triggered_at) > _API_UNREACHABLE_HOURS:
-                    new_status = self._apply_retry_limit(data, "Pending", model)
+                    new_status = self._resolve_failure(data, model)
                     self._reset_active_fields(data, new_status)
                     updates.append((fpath, data))
                     logger.warning(
@@ -417,7 +428,7 @@ class CIDispatcher:
             if azure_state is None:
                 # API unreachable — apply fallback timeout
                 if triggered_at and self._hours_since(triggered_at) > _API_UNREACHABLE_HOURS:
-                    new_status = self._apply_retry_limit(data, "Pending", model)
+                    new_status = self._resolve_failure(data, model)
                     self._reset_active_fields(data, new_status)
                     updates.append((fpath, data))
                     logger.warning(
@@ -436,7 +447,7 @@ class CIDispatcher:
                     # writes back Finished. Give it a grace period.
                     if triggered_at and self._hours_since(triggered_at) > _SUCCEEDED_GRACE_HOURS:
                         # Grace period expired — write-back likely failed
-                        new_status = self._apply_retry_limit(data, "Pending", model)
+                        new_status = self._resolve_failure(data, model)
                         self._reset_active_fields(data, new_status)
                         updates.append((fpath, data))
                         logger.warning(
@@ -449,8 +460,9 @@ class CIDispatcher:
                         data["status"] = "Running"
                         updates.append((fpath, data))
                 else:
-                    # failed or canceled → retry immediately
-                    new_status = self._apply_retry_limit(data, "Pending", model)
+                    # failed or canceled → resolve to retry (Pending) or a
+                    # terminal failed status depending on enable_retry
+                    new_status = self._resolve_failure(data, model)
                     self._reset_active_fields(data, new_status)
                     updates.append((fpath, data))
                     logger.info(
@@ -462,7 +474,7 @@ class CIDispatcher:
             # ── Azure: inProgress / canceling ──
             # Check absolute max runtime
             if triggered_at and self._hours_since(triggered_at) > _MAX_ACTIVE_HOURS:
-                new_status = self._apply_retry_limit(data, "Pending", model)
+                new_status = self._resolve_failure(data, model)
                 self._reset_active_fields(data, new_status)
                 updates.append((fpath, data))
                 logger.warning(
@@ -573,6 +585,12 @@ class CIDispatcher:
             data["last_failed_time"] = (
                 datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
             )
+        elif new_status in ("Quant Failed", "Eval Failed"):
+            # Terminal failure surfaced from Azure (retry disabled).  Keep
+            # ci_run_id so the Azure run stays inspectable; just stamp the time.
+            data["last_failed_time"] = (
+                datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+            )
 
     @staticmethod
     def _apply_retry_limit(data: dict, candidate_status: str, model: str) -> str:
@@ -600,3 +618,23 @@ class CIDispatcher:
             model, retry_count, _MAX_RETRIES,
         )
         return "Pending"
+
+    def _resolve_failure(self, data: dict, model: str) -> str:
+        """Decide what an active run that cannot continue should become.
+
+        * ``enable_retry=True``  → reset to ``Pending`` (re-dispatched next
+          cycle) until ``_MAX_RETRIES`` is exhausted, then ``Failed``.
+        * ``enable_retry=False`` → map to a terminal failed status
+          (``Quant Failed`` / ``Eval Failed``) so the UI reflects the failure
+          immediately and the entry is NOT re-dispatched.
+        """
+        if self._enable_retry:
+            return self._apply_retry_limit(data, "Pending", model)
+        return self._terminal_failed_status(data)
+
+    @staticmethod
+    def _terminal_failed_status(data: dict) -> str:
+        """Terminal failed status for an entry, keyed off its pipeline script."""
+        if data.get("script") == "auto_eval":
+            return "Eval Failed"
+        return "Quant Failed"

src/populate.py

@@ -185,7 +185,15 @@ def _infer_quant_status(entry: dict, result_index: dict) -> str:
     agg = entry.get("_matched_aggregate")
     if agg is None:
         return original_status
-    return _derive_status_from_aggregate(agg)
+    derived = _derive_status_from_aggregate(agg)
+    # The entry is still actively running on Azure (Running/Triggered/Waiting).
+    # A *partial* aggregate (quant done but eval not finished) must NOT pull it
+    # out of the Running queue — only a terminal outcome (Finished / a failure)
+    # may override a live active status.  Otherwise the dispatcher log shows
+    # "Running" while the UI wrongly lists it as pending/finished.
+    if original_status in ("Running", "Triggered", "Waiting") and derived in ("Quantized", "Partial"):
+        return original_status
+    return derived
 
 
 def _infer_eval_status(entry: dict, result_index: dict) -> str:
@@ -336,9 +344,16 @@ def _load_queue_entries(save_path: str, request_type: str = None) -> list[dict]:
 
 
 def _split_by_status(all_evals: list[dict]) -> tuple[list, list, list, list]:
-    """Split entries into (pending, running, finished, failed) lists by status."""
-    pending  = [e for e in all_evals if e.get("status") in ("Pending", "Rerun", "Waiting", "Quantized")]
-    running  = [e for e in all_evals if e.get("status") in ("Running", "Triggered")]
+    """Split entries into (pending, running, finished, failed) lists by status.
+
+    ``Waiting`` is an *active* status (the CI run is queued/executing on Azure)
+    and is treated as Running everywhere else in the system (CIDispatcher
+    ``_collect_status_summary``, ``queue_eta``, retry logic).  It must live in
+    the running bucket so the UI matches the dispatcher log instead of showing
+    a model as pending while the log already reports it as Running.
+    """
+    pending  = [e for e in all_evals if e.get("status") in ("Pending", "Rerun", "Quantized")]
+    running  = [e for e in all_evals if e.get("status") in ("Running", "Triggered", "Waiting")]
     finished = [e for e in all_evals
                 if e.get("status", "").startswith("Finished")
                 or e.get("status") == "PENDING_NEW_EVAL"]
@@ -351,6 +366,21 @@ def _split_by_status(all_evals: list[dict]) -> tuple[list, list, list, list]:
     return pending, running, finished, failed
 
 
+def _drop_resolved_quant_failures(failed: list[dict], all_entries: list[dict]) -> list[dict]:
+    """Remove failed quant entries superseded by a later submission."""
+    latest_submission_by_key: dict[tuple[str, str], str] = {}
+    for entry in all_entries:
+        key = _quant_match_key(entry)
+        submitted_time = entry.get("submitted_time", "")
+        if submitted_time >= latest_submission_by_key.get(key, ""):
+            latest_submission_by_key[key] = submitted_time
+
+    return [
+        entry for entry in failed
+        if latest_submission_by_key.get(_quant_match_key(entry), "") <= entry.get("submitted_time", "")
+    ]
+
+
 def _build_queue_dfs(pending: list, running: list, finished: list, failed: list,
                      cols: list) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, pd.DataFrame]:
     """Build DataFrames from split lists, keeping only the requested *cols*."""
@@ -438,6 +468,8 @@ def get_evaluation_queue_df(save_path: str, cols: list,
                 entry["status"] = _infer_eval_status(entry, result_index)
 
     pending, running, finished, failed = _split_by_status(all_evals)
+    if request_type == "quant":
+        failed = _drop_resolved_quant_failures(failed, all_evals)
 
     # Inject ETA for pending entries
     _inject_eta(pending, running, concurrency=2)

src/submission/submit.py

@@ -381,6 +381,7 @@ def add_new_eval(
     hardware_override: str | None = None,
     gpu_count_override: int | None = None,
     submitted_by: str = "",
+    submitted_orgs: list[str] | None = None,
     user_token: str | None = None,
 ):
     """Submit an already-quantized model for evaluation (generator with progress).
@@ -620,6 +621,7 @@ def add_new_eval(
         "status": "Pending",
         "submitted_time": current_time,
         "submitted_by": submitted_by,
+        "submitted_orgs": submitted_orgs or [],
         "model_type": "quantization",
         "job_id": -1,
         "job_start_time": None,
@@ -684,6 +686,7 @@ def add_new_quant(
     hardware_override: str | None = None,
     gpu_count_override: int | None = None,
     submitted_by: str = "",
+    submitted_orgs: list[str] | None = None,
     user_token: str | None = None,
 ):
     """Submit an FP model for quantization + evaluation (generator with progress).
@@ -907,6 +910,7 @@ def add_new_quant(
         "status": "Pending",
         "submitted_time": current_time,
         "submitted_by": submitted_by,
+        "submitted_orgs": submitted_orgs or [],
         "model_type": "quantization",
         "job_id": -1,
         "job_start_time": None,

tests/test_auto_pipeline_results.py

@@ -8,7 +8,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from src.leaderboard.read_auto_pipeline_results import get_auto_pipeline_results_df
 from src.leaderboard.read_auto_pipeline_results import AUTO_PIPELINE_SEARCH_COL, AUTO_PIPELINE_SORT_COL
-from src.app_helpers.pipeline_table import filter_auto_pipeline_table
+from src.app_helpers.pipeline_table import embed_dl_icon_in_hf_model_cell, filter_auto_pipeline_table
 
 
 class AutoPipelineResultsTests(unittest.TestCase):
@@ -138,6 +138,15 @@ class AutoPipelineResultsTests(unittest.TestCase):
 
 
 class AutoPipelineFilterTests(unittest.TestCase):
+    def test_download_icon_is_embedded_in_hf_model_cell(self):
+        cell = '<a target="_blank" href="https://huggingface.co/INC4AI/Qwen3-W4A16">INC4AI/Qwen3-W4A16</a>'
+
+        result = embed_dl_icon_in_hf_model_cell(cell)
+
+        self.assertIn('class="dl-cell-link"', result)
+        self.assertIn('data-repo="INC4AI/Qwen3-W4A16"', result)
+        self.assertIn('title="INC4AI/Qwen3-W4A16"', result)
+
     def test_empty_pipeline_selection_returns_no_rows(self):
         update = filter_auto_pipeline_table(
             self._sample_df(),

tests/test_ci_dispatcher.py

@@ -70,8 +70,14 @@ def _old_str(hours_ago):
     return dt.strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
-def _make_dispatcher(status_path, requests_path=None, max_concurrent=4, pat="fake-pat"):
-    """Build a CIDispatcher with a fully-mocked repo."""
+def _make_dispatcher(status_path, requests_path=None, max_concurrent=4, pat="fake-pat",
+                     enable_retry=True):
+    """Build a CIDispatcher with a fully-mocked repo.
+
+    ``enable_retry`` defaults to ``True`` because most reconcile tests assert
+    the retry path (failure → Pending → Failed).  Tests for the retry-disabled
+    behaviour (failure → terminal Quant/Eval Failed) pass ``enable_retry=False``.
+    """
     repo = MagicMock()
     repo.active_branch.name = "main"
     repo.working_dir = os.path.dirname(status_path)
@@ -87,6 +93,7 @@ def _make_dispatcher(status_path, requests_path=None, max_concurrent=4, pat="fak
         requests_path=requests_path or status_path,
         azure_pat=pat,
         max_concurrent=max_concurrent,
+        enable_retry=enable_retry,
     )
 
 
@@ -516,6 +523,73 @@ class TestReconcileActiveRuns:
         d._repo.remotes.origin.push.assert_not_called()
 
 
+# ═══════════════════════════════════════════════════════════════════════
+# 4b. _reconcile_active_runs with retry DISABLED (terminal failed statuses)
+# ═══════════════════════════════════════════════════════════════════════
+
+class TestReconcileNoRetry:
+    """With enable_retry=False, Azure failures map to terminal failed statuses
+    (Quant Failed / Eval Failed) instead of being reset to Pending."""
+
+    def setup_method(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="test_noretry_")
+        self._status_dir = os.path.join(self._tmpdir, "status")
+        os.makedirs(self._status_dir)
+
+    def _dispatcher(self):
+        d = _make_dispatcher(self._status_dir, enable_retry=False)
+        d._repo.working_dir = self._tmpdir
+        return d
+
+    def test_quant_failed_on_azure_failure(self):
+        fp = _write_status(self._status_dir, "org", "a.json", {
+            "model": "org/a", "status": "Running", "script": "auto_quant",
+            "ci_run_id": 10, "triggered_time": _now_str(),
+        })
+        d = self._dispatcher()
+        resp = _mock_azure_response(200, {"state": "completed", "result": "failed"})
+        with patch("src.ci_dispatcher.http_requests.get", return_value=resp):
+            d._reconcile_active_runs()
+        data = _read_status(fp)
+        assert data["status"] == "Quant Failed"
+        assert data["ci_run_id"] == 10          # preserved for debugging
+        assert "retry_count" not in data         # no retry bookkeeping
+
+    def test_eval_failed_on_azure_canceled(self):
+        fp = _write_status(self._status_dir, "org", "b.json", {
+            "model": "org/b", "status": "Triggered", "script": "auto_eval",
+            "ci_run_id": 20, "triggered_time": _now_str(),
+        })
+        d = self._dispatcher()
+        resp = _mock_azure_response(200, {"state": "completed", "result": "canceled"})
+        with patch("src.ci_dispatcher.http_requests.get", return_value=resp):
+            d._reconcile_active_runs()
+        assert _read_status(fp)["status"] == "Eval Failed"
+
+    def test_in_progress_still_updates_to_running(self):
+        """Non-failure reconciliation (inProgress → Running) works regardless."""
+        fp = _write_status(self._status_dir, "org", "c.json", {
+            "model": "org/c", "status": "Triggered", "script": "auto_quant",
+            "ci_run_id": 30, "triggered_time": _now_str(),
+        })
+        d = self._dispatcher()
+        resp = _mock_azure_response(200, {"state": "inProgress", "result": ""})
+        with patch("src.ci_dispatcher.http_requests.get", return_value=resp):
+            d._reconcile_active_runs()
+        assert _read_status(fp)["status"] == "Running"
+
+    def test_succeeded_stays_running_within_grace(self):
+        fp = _write_status(self._status_dir, "org", "d.json", {
+            "model": "org/d", "status": "Running", "script": "auto_quant",
+            "ci_run_id": 40, "triggered_time": _now_str(),
+        })
+        d = self._dispatcher()
+        resp = _mock_azure_response(200, {"state": "completed", "result": "succeeded"})
+        with patch("src.ci_dispatcher.http_requests.get", return_value=resp):
+            d._reconcile_active_runs()
+        assert _read_status(fp)["status"] == "Running"
+
+
 # ═══════════════════════════════════════════════════════════════════════
 # 5. _collect_status_summary
 # ═══════════════════════════════════════���═══════════════════════════════

tests/test_eval_queue.py

@@ -436,6 +436,109 @@ def test_submitted_quant_is_failed_when_result_is_newer():
         shutil.rmtree(results_dir, ignore_errors=True)
 
 
+def test_resubmitted_quant_pending_removes_old_failed_entry():
+    """A later accepted quant re-submit should remove the old failed row."""
+    tmpdir = tempfile.mkdtemp(prefix="test_queue_resubmit_pending_quant_")
+    results_dir = tempfile.mkdtemp(prefix="test_results_resubmit_pending_quant_")
+    try:
+        failed_entry = {
+            "model": "org/model",
+            "revision": "main",
+            "private": False,
+            "quant_scheme": "INT4 (W4A16)",
+            "quant_precision": "4bit",
+            "quant_weight_dtype": "int4",
+            "status": "Pending",
+            "submitted_time": "2026-05-21T08:00:00Z",
+            "script": "auto_quant",
+            "model_params": 7.0,
+        }
+        pending_entry = dict(failed_entry, status="Pending", submitted_time="2026-05-21T10:00:00Z")
+        with open(os.path.join(tmpdir, "failed_request.json"), "w") as fh:
+            json.dump(failed_entry, fh)
+        with open(os.path.join(tmpdir, "pending_request.json"), "w") as fh:
+            json.dump(pending_entry, fh)
+
+        failed_result = {
+            "model_id": "org/model",
+            "generated_at": "2026-05-21T09:00:00Z",
+            "run_dir": "runs/failed",
+            "copied_files": ["x"],
+            "quant_summary": {"scheme": "W4A16", "status": "failed"},
+            "accuracy": {"status": "missing"},
+        }
+        with open(os.path.join(results_dir, "results_failed.json"), "w") as fh:
+            json.dump(failed_result, fh)
+
+        finished_df, running_df, pending_df, failed_df = get_evaluation_queue_df(
+            tmpdir, QUANT_COLS, request_type="quant", results_path=results_dir
+        )
+
+        assert len(finished_df) == 0
+        assert len(pending_df) == 1
+        assert len(failed_df) == 0
+        assert pending_df["model"].astype(str).str.contains("org/model", regex=False).any()
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+        shutil.rmtree(results_dir, ignore_errors=True)
+
+
+def test_resubmitted_quant_success_removes_old_failed_entry():
+    """A later successful quant re-submit should remove the old failed row."""
+    tmpdir = tempfile.mkdtemp(prefix="test_queue_resolved_quant_")
+    results_dir = tempfile.mkdtemp(prefix="test_results_resolved_quant_")
+    try:
+        failed_entry = {
+            "model": "org/model",
+            "revision": "main",
+            "private": False,
+            "quant_scheme": "INT4 (W4A16)",
+            "quant_precision": "4bit",
+            "quant_weight_dtype": "int4",
+            "status": "Pending",
+            "submitted_time": "2026-05-21T08:00:00Z",
+            "script": "auto_quant",
+            "model_params": 7.0,
+        }
+        success_entry = dict(failed_entry, status="Pending", submitted_time="2026-05-21T10:00:00Z")
+        with open(os.path.join(tmpdir, "failed_request.json"), "w") as fh:
+            json.dump(failed_entry, fh)
+        with open(os.path.join(tmpdir, "success_request.json"), "w") as fh:
+            json.dump(success_entry, fh)
+
+        failed_result = {
+            "model_id": "org/model",
+            "generated_at": "2026-05-21T09:00:00Z",
+            "run_dir": "runs/failed",
+            "copied_files": ["x"],
+            "quant_summary": {"scheme": "W4A16", "status": "failed"},
+            "accuracy": {"status": "missing"},
+        }
+        success_result = {
+            "model_id": "org/model",
+            "generated_at": "2026-05-21T11:00:00Z",
+            "run_dir": "runs/success",
+            "copied_files": ["x"],
+            "quant_summary": {"scheme": "W4A16", "status": "success"},
+            "accuracy": {"status": "success"},
+        }
+        with open(os.path.join(results_dir, "results_failed.json"), "w") as fh:
+            json.dump(failed_result, fh)
+        with open(os.path.join(results_dir, "results_success.json"), "w") as fh:
+            json.dump(success_result, fh)
+
+        finished_df, running_df, pending_df, failed_df = get_evaluation_queue_df(
+            tmpdir, QUANT_COLS, request_type="quant", results_path=results_dir
+        )
+
+        assert len(finished_df) == 1
+        assert len(failed_df) == 0
+        assert finished_df["model"].astype(str).str.contains("org/model", regex=False).any()
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+        shutil.rmtree(results_dir, ignore_errors=True)
+
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # Test 6: Synthetic — unknown status entries are silently dropped
 # ══════════════════════════════════════════════════════════════════════���════════

tests/test_submit.py

@@ -56,7 +56,7 @@ def _is_error(result: str) -> bool:
 
 def _is_success(result: str) -> bool:
     """Check if result is a styled_message (green) response."""
-    return "color: green" in result
+    return "color: green" in result or "#f0fdf4" in result
 
 def _is_warning(result: str) -> bool:
     """Check if result is a styled_warning (orange) response."""
@@ -272,11 +272,12 @@ def test_add_new_quant_allows_whitelisted_resubmit_for_failed_entry(monkeypatch,
     monkeypatch.setattr(submit_module, "compute_single_eta", lambda *_args, **_kwargs: 1)
     monkeypatch.setattr(submit_module, "format_eta", lambda *_args, **_kwargs: "1h")
 
-    uploaded = {"called": False, "file_tag": None}
+    uploaded = {"called": False, "file_tag": None, "entry": None}
 
     def _fake_upload(entry, user_name, model_path, file_tag, model, task_label="eval"):
         uploaded["called"] = True
         uploaded["file_tag"] = file_tag
+        uploaded["entry"] = entry
 
     monkeypatch.setattr(submit_module, "_upload_to_hub", _fake_upload)
 
@@ -286,10 +287,12 @@ def test_add_new_quant_allows_whitelisted_resubmit_for_failed_entry(monkeypatch,
         private=False,
         quant_scheme="INT4 (W4A16)",
         submitted_by="alice",
+        submitted_orgs=["intel", "research"],
     ))
 
     assert uploaded["called"] is True
     assert _is_success(result)
+    assert uploaded["entry"]["submitted_orgs"] == ["intel", "research"]
     # Re-submission must not overwrite the previous failed status file: the
     # filename gets a timestamp suffix appended to keep both records.
     assert uploaded["file_tag"] is not None
@@ -327,6 +330,7 @@ def test_add_new_eval_allows_whitelisted_resubmit_for_failed_entry(monkeypatch,
     monkeypatch.setattr(submit_module, "_SUBMITTER_DATES", {})
     monkeypatch.setattr(submit_module, "_load_eval_cache", lambda: None)
     monkeypatch.setattr(submit_module, "_common_pre_checks", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr(submit_module, "is_gguf_on_hub", lambda *_args, **_kwargs: (False, "", None, None))
     monkeypatch.setattr(
         submit_module,
         "is_model_on_hub",
@@ -360,11 +364,12 @@ def test_add_new_eval_allows_whitelisted_resubmit_for_failed_entry(monkeypatch,
     monkeypatch.setattr(submit_module, "compute_single_eta", lambda *_args, **_kwargs: 1)
     monkeypatch.setattr(submit_module, "format_eta", lambda *_args, **_kwargs: "1h")
 
-    uploaded = {"called": False, "file_tag": None}
+    uploaded = {"called": False, "file_tag": None, "entry": None}
 
     def _fake_upload(entry, user_name, model_path, file_tag, model, task_label="eval"):
         uploaded["called"] = True
         uploaded["file_tag"] = file_tag
+        uploaded["entry"] = entry
 
     monkeypatch.setattr(submit_module, "_upload_to_hub", _fake_upload)
 
@@ -374,10 +379,12 @@ def test_add_new_eval_allows_whitelisted_resubmit_for_failed_entry(monkeypatch,
         private=False,
         compute_dtype="INT4 (W4A16)",
         submitted_by="alice",
+        submitted_orgs=["intel", "research"],
     ))
 
     assert uploaded["called"] is True
     assert _is_success(result)
+    assert uploaded["entry"]["submitted_orgs"] == ["intel", "research"]
     # Re-submission must not overwrite the previous failed status file: the
     # filename gets a timestamp suffix appended to keep both records.
     assert uploaded["file_tag"] is not None