@meridiona/meridian-darwin-arm64 1.65.0 → 1.66.1

package/VERSION

@@ -1 +1 @@
-1.65.0
+1.66.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meridiona/meridian-darwin-arm64",
-  "version": "1.65.0",
+  "version": "1.66.1",
   "description": "Prebuilt Meridian app for macOS arm64 (daemon binary + dashboard + Python services). Installed via @meridiona/meridian.",
   "homepage": "https://github.com/Meridiona/meridian",
   "repository": {

package/services/agents/_state.py

@@ -9,13 +9,22 @@ from typing import Any
 # and read by every route module.
 app_state: dict[str, Any] = {}
 
-# Shared prefetch progress, guarded by prefetch_lock. states: idle|downloading|done|error
+# Shared prefetch progress, guarded by prefetch_lock. states: idle|downloading|done|error.
+# `received`/`total` are AGGREGATE byte counts summed across every pipeline model
+# (llm + reranker + embedder), so the wizard's progress bar has a single honest
+# denominator. The wire contract the Rust tray decodes is exactly
+# state/received/total/error/speed (tray/src-tauri/src/mlx_server.rs::PrefetchStatus);
+# `models` is an additive per-model breakdown the tray ignores.
 prefetch_state: dict[str, Any] = {
     "state": "idle",
-    "model_id": None,
     "received": 0,
     "total": 0,
+    # Live transfer rate in bytes/sec, sourced from HF's own tqdm progress
+    # (see routes/prefetch._SpeedTqdm); 0 when not actively transferring.
+    "speed": 0.0,
     "error": None,
+    # Per-model rows: {"role", "model_id", "loader", "received", "total", "state"}.
+    "models": [],
 }
 prefetch_lock = threading.Lock()
 

package/services/agents/mlx_classifier.py

@@ -15,13 +15,16 @@ import time
 from contextlib import contextmanager
 from typing import Any, Iterator
 
-from agents import observability
+from agents import model_registry, observability
 
 log = logging.getLogger("agents.mlx_classifier")
 tracer = observability.setup("meridian-mlx-classifier")
 
-# Default model — the agent server runs a single hardcoded model.
-MODEL_ID = "mlx-community/Qwen3.5-2B-OptiQ-4bit"
+# Generative/classifier checkpoint — resolved from the model registry (the single
+# source of truth for all three pipeline models), env-overridable via MERIDIAN_LLM_ID.
+# Exposed as a module attribute for external compatibility; the live value is read
+# from the registry per-call inside _get_model() so a runtime env change is honoured.
+MODEL_ID = model_registry.llm_id()
 
 _IDLE_EVICT_S = float(os.environ.get("MLX_IDLE_EVICT_S", "120"))
 
@@ -48,7 +51,7 @@ def _get_model() -> _ModelBundle:
     Cache-miss load is done under _model_lock (double-checked) so concurrent
     callers can't double-load and the idle evictor can't race the load.
     """
-    model_id = MODEL_ID
+    model_id = model_registry.llm_id()
     cached = _model_cache.get(model_id)
     if cached is not None:
         return cached
@@ -65,14 +68,14 @@ def _get_model() -> _ModelBundle:
                 "Install with: pip install 'mlx-lm>=0.22'"
             ) from exc
 
-        log.info("run_task_linker_mlx: loading %s (first call this process)", model_id)
+        log.info("mlx_classifier: loading %s (first call this process)", model_id)
         t0 = time.time()
         mlx_model, tokenizer = mlx_lm.load(
             model_id,
             tokenizer_config={"trust_remote_code": True},
         )
         bundle = _ModelBundle(mlx_model, tokenizer)
-        log.info("run_task_linker_mlx: model loaded in %.1fs", time.time() - t0)
+        log.info("mlx_classifier: model loaded in %.1fs", time.time() - t0)
 
         _model_cache[model_id] = bundle
         _tokenizer_cache[model_id] = tokenizer
@@ -81,7 +84,7 @@ def _get_model() -> _ModelBundle:
 
 def _get_tokenizer() -> Any:
     """Return the HF tokenizer for the current model, loading the model if needed."""
-    model_id = MODEL_ID
+    model_id = model_registry.llm_id()
     tok = _tokenizer_cache.get(model_id)
     if tok is not None:
         return tok
@@ -135,7 +138,7 @@ def maybe_evict_idle(idle_s: float | None = None) -> float | None:
             mx.clear_cache()
             freed = max(0.0, (before - mx.get_active_memory()) / 1e9)
         log.info(
-            "run_task_linker_mlx: evicted idle model (idle ≥ %.0fs), freed ~%.1f GB",
+            "mlx_classifier: evicted idle model (idle ≥ %.0fs), freed ~%.1f GB",
             ttl, freed,
         )
         return freed
@@ -169,7 +172,7 @@ def evict_resident_model() -> float | None:
         if mx is not None:
             mx.clear_cache()
             freed = max(0.0, (before - mx.get_active_memory()) / 1e9)
-        log.info("run_task_linker_mlx: force-evicted resident model, freed ~%.1f GB", freed)
+        log.info("mlx_classifier: force-evicted resident model, freed ~%.1f GB", freed)
         return freed
     finally:
         _model_lock.release()

package/services/agents/model_registry.py

@@ -0,0 +1,108 @@
+"""Single source of truth for the on-device models the pipeline needs.
+
+The end-to-end worklog pipeline (classification → worklog update) runs three
+distinct models, each in its own single-slot turn (the runtime never keeps two
+resident at once — see ``mlx_classifier.evict_resident_model``):
+
+    role      default checkpoint                       loader          used by
+    ────────  ───────────────────────────────────────  ──────────────  ──────────────────────────────────
+    llm       mlx-community/Qwen3.5-2B-OptiQ-4bit       mlx_lm          classify · match · /summarise · /activity_report · worklog synth · propose
+    reranker  kerncore/Qwen3-Reranker-0.6B-MLX-4bit    mlx_lm          ticket↔worklog scoring (/rerank)
+    embedder  mlx-community/Qwen3-Embedding-0.6B-8bit   mlx_embeddings  session-distillation SemDeDup (/distill_hour)
+
+There is no separate "classifier" model: classification and matching run on the
+``llm`` checkpoint via the OpenAI-compatible endpoint.
+
+Every checkpoint is env-overridable (defaults below) so eval/experiments can
+swap any role without code edits. This module is the ONLY place these ids and
+their HuggingFace download filesets are declared — ``mlx_classifier``,
+``reranker``, ``session_distiller`` and the ``/prefetch_model`` route all read
+from here, so onboarding can eagerly fetch exactly the set the runtime will load.
+
+# Who reads this
+    agents.mlx_classifier      → MODEL_ID            (llm)
+    agents.reranker            → _RERANKER_ID        (reranker)
+    agents.session_distiller   → embedder load       (embedder)
+    agents.routes.prefetch     → eager multi-model download for the setup wizard
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+# mlx_lm.load()'s default fileset — exactly what a generative or reranker MLX
+# repo resolves on load(). The mlx-community embedding repos are plain
+# transformer encoders shipping the same config/safetensors/tokenizer layout,
+# so this pattern set covers all three roles. Stored as a tuple (immutable) so
+# each ModelSpec gets independent identity — list mutation would silently corrupt
+# all three specs' snapshot_download filters simultaneously.
+_MLX_ALLOW_PATTERNS: tuple[str, ...] = (
+    "*.json", "model*.safetensors", "*.py", "tokenizer.model",
+    "*.tiktoken", "tiktoken.model", "*.txt", "*.jsonl", "*.jinja",
+)
+
+
+@dataclass(frozen=True)
+class ModelSpec:
+    """One model role: its env override, default checkpoint, loader, and fileset.
+
+    ``loader`` selects the runtime entry point — ``"mlx_lm"`` for generative /
+    reranker weights (``mlx_lm.load``) and ``"mlx_embeddings"`` for the encoder
+    (``mlx_embeddings.load``). ``allow_patterns`` is the HF download filter the
+    prefetch route applies so it fetches exactly what ``load()`` will resolve.
+    """
+
+    role: str
+    env_var: str
+    default_id: str
+    loader: str
+    allow_patterns: tuple[str, ...]
+
+    @property
+    def model_id(self) -> str:
+        """Resolved checkpoint id — the env override if set, else the default."""
+        return os.environ.get(self.env_var, self.default_id)
+
+
+LLM = ModelSpec(
+    role="llm",
+    env_var="MERIDIAN_LLM_ID",
+    default_id="mlx-community/Qwen3.5-2B-OptiQ-4bit",
+    loader="mlx_lm",
+    allow_patterns=_MLX_ALLOW_PATTERNS,
+)
+
+RERANKER = ModelSpec(
+    role="reranker",
+    env_var="WORKLOG_RERANKER_ID",
+    default_id="kerncore/Qwen3-Reranker-0.6B-MLX-4bit",
+    loader="mlx_lm",
+    allow_patterns=_MLX_ALLOW_PATTERNS,
+)
+
+EMBEDDER = ModelSpec(
+    role="embedder",
+    env_var="MERIDIAN_EMBEDDER_ID",
+    default_id="mlx-community/Qwen3-Embedding-0.6B-8bit",
+    loader="mlx_embeddings",
+    allow_patterns=_MLX_ALLOW_PATTERNS,
+)
+
+# Ordered llm → reranker → embedder: the wizard prefetches in this order, and the
+# llm is largest so its progress dominates the bar first.
+ALL_SPECS: tuple[ModelSpec, ...] = (LLM, RERANKER, EMBEDDER)
+
+
+def llm_id() -> str:
+    """Resolved generative/classifier checkpoint id."""
+    return LLM.model_id
+
+
+def reranker_id() -> str:
+    """Resolved reranker checkpoint id."""
+    return RERANKER.model_id
+
+
+def embedder_id() -> str:
+    """Resolved embedder checkpoint id."""
+    return EMBEDDER.model_id

package/services/agents/pm_worklog_update/config.py

@@ -12,6 +12,8 @@ from __future__ import annotations
 
 import os
 
+from agents import model_registry
+
 # Re-export the shared paths so callers don't have to know about the parent
 # config module.
 from agents.config import MERIDIAN_DB, MERIDIAN_HOME  # noqa: F401
@@ -27,7 +29,7 @@ PM_WORKLOG_INTERVAL_HOURS = float(os.environ.get("PM_WORKLOG_INTERVAL_HOURS", "1
 # OpenAILike. The port is the same one the classifier uses.
 MLX_SERVER_HOST   = os.environ.get("MLX_SERVER_HOST", "127.0.0.1")
 MLX_SERVER_PORT   = int(os.environ.get("MLX_SERVER_PORT", "7823"))
-MLX_SERVER_MODEL  = os.environ.get("MLX_SERVER_MODEL", "mlx-community/Qwen3.5-2B-OptiQ-4bit")
+MLX_SERVER_MODEL  = os.environ.get("MLX_SERVER_MODEL") or model_registry.llm_id()
 
 # Token caps. The MLX model exposes 128-262K context — a single Synthesise
 # call comfortably swallows even the heaviest hour of work.

package/services/agents/reranker.py

@@ -16,16 +16,17 @@ from __future__ import annotations
 
 import gc
 import logging
-import os
 import threading
 import time
 from typing import Any
 
+from agents import model_registry
+
 log = logging.getLogger("meridian.reranker")
 
-_RERANKER_ID = os.environ.get(
-    "WORKLOG_RERANKER_ID", "kerncore/Qwen3-Reranker-0.6B-MLX-4bit"
-)
+# Reranker checkpoint — resolved from the model registry, still env-overridable
+# via WORKLOG_RERANKER_ID (the registry owns that env var).
+_RERANKER_ID = model_registry.reranker_id()
 
 # Reranker prompt scaffold — matches the calibration used in the offline
 # benchmark (services/tests/evals/cluster/test_matcher_benchmark.py).

package/services/agents/routes/prefetch.py

@@ -1,25 +1,42 @@
 """Prefetch routes — /prefetch_model and /prefetch_status.
 
-Eager, spec-aware model download for the onboarding wizard. The wizard's Model
-step calls /prefetch_model right after the runtime is chosen, then polls
-/prefetch_status for live progress. Downloads run in a background thread so the
-event loop is never blocked; progress is shared via prefetch_state in agents._state.
+Eager, registry-driven download of EVERY model the end-to-end pipeline needs
+(llm + reranker + embedder — see agents.model_registry), so the onboarding wizard
+can fetch the whole set before the user reaches the dashboard and no first
+worklog run stalls on a silent mid-pipeline download.
+
+The wizard's Model step calls /prefetch_model once the runtime is up, then polls
+/prefetch_status for live progress. Downloads run in one background thread
+(sequential, so bandwidth isn't fragmented) and never block the event loop;
+progress is shared via prefetch_state in agents._state. `received`/`total` are
+aggregate byte counts across all models — the single denominator the wizard's
+progress bar renders.
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 import threading
+import time
 from pathlib import Path
 
 from fastapi import APIRouter
 from opentelemetry import trace
 
-from agents._state import app_state, prefetch_state, prefetch_lock
+from agents import model_registry
+from agents._state import app_state, prefetch_lock, prefetch_state
 
 log = logging.getLogger("agents.server")
 
 router = APIRouter()
 
+# Speed is derived from the growth of on-disk `received` between /prefetch_status
+# polls — NOT from a tqdm hook. hf_xet (the Xet accelerator these models use) does
+# its download in Rust and bypasses the classic tqdm bar, so a tqdm_class never
+# fires; the byte-delta approach works for any backend. Stored as a dict so both
+# functions can mutate it in-place without `global` declarations.
+_speed_state: dict[str, float | int] = {"recv": 0, "ts": 0.0}
+
 
 def _hf_cache_dir_for(model_id: str) -> Path:
     """The HF hub cache directory for `model_id` (where partial + complete blobs land)."""
@@ -28,111 +45,218 @@ def _hf_cache_dir_for(model_id: str) -> Path:
 
 
 def _dir_size_bytes(path: Path) -> int:
-    """Sum of all file sizes under `path` (includes HF `.incomplete` partials → live progress)."""
+    """Bytes actually downloaded under `path` (HF blobs + `.incomplete` partials).
+
+    Counts only real files, NEVER the ``snapshots/`` symlinks: HF stores each file
+    once in ``blobs/`` and symlinks it into ``snapshots/``, so following the links
+    would double-count every finished file and push progress past 100%.
+    """
     total = 0
     if path.exists():
         for f in path.rglob("*"):
             try:
-                if f.is_file():
+                if f.is_file() and not f.is_symlink():
                     total += f.stat().st_size
             except OSError:
                 pass  # file may be deleted mid-walk; skip silently
     return total
 
 
-def _prefetch_total_bytes(model_id: str) -> int:
-    """Authoritative download size: sum HF sibling sizes filtered to the load() patterns.
+def _spec_total_bytes(spec: model_registry.ModelSpec) -> int:
+    """Authoritative download size for one model: sum HF sibling sizes filtered to
+    the spec's load() patterns.
 
     Computed upfront so the wizard's progress bar has a stable denominator, instead
     of summing concurrent per-file tqdm totals (which lurch as new bars spawn).
     """
     import fnmatch
-    from huggingface_hub import HfApi
 
-    # Lazy import avoids a circular import: agents.server imports this module at
-    # load time, so prefetch.py cannot import from agents.server at module scope.
-    from agents.server import _MODEL_ALLOW_PATTERNS
+    from huggingface_hub import HfApi
 
-    info = HfApi().model_info(model_id, files_metadata=True)
+    info = HfApi().model_info(spec.model_id, files_metadata=True)
     total = 0
     for sib in info.siblings or []:
-        if any(fnmatch.fnmatch(sib.rfilename, pat) for pat in _MODEL_ALLOW_PATTERNS):
+        if any(fnmatch.fnmatch(sib.rfilename, pat) for pat in spec.allow_patterns):
             total += sib.size or 0
     return total
 
 
-def _run_prefetch(model_id: str) -> None:
-    """Background worker: download the model's weights to the HF cache (no load)."""
-    from agents.server import _MODEL_ALLOW_PATTERNS
+def _download_spec(spec: model_registry.ModelSpec) -> None:
+    """Download one model's weights to the HF cache (no load into memory).
+
+    All specs go through ``snapshot_download`` (filtered to the spec's
+    allow_patterns); ``hf-xet`` transparently accelerates the Xet-backed transfers.
+    ``mlx_lm.load`` / ``mlx_embeddings.load`` resolve the files straight from the
+    cache afterwards. Only disk is touched — the single-slot runtime loads each
+    model lazily on first use.
+    """
+    from huggingface_hub import snapshot_download
+    snapshot_download(spec.model_id, allow_patterns=spec.allow_patterns)
 
+
+def _run_prefetch(specs: list[model_registry.ModelSpec]) -> None:
+    """Background worker: download every model in `specs` to the HF cache in order."""
     tracer = trace.get_tracer(__name__)
-    with tracer.start_as_current_span("model_prefetch") as span:
-        span.set_attribute("model_id", model_id)
+    with tracer.start_as_current_span("model_prefetch_all") as root:
+        root.set_attribute("model_count", len(specs))
         try:
-            try:
-                from mlx_lm.utils import _download as _mlx_download
-                _mlx_download(model_id)  # exact fileset load() resolves; download-only
-            except (ImportError, AttributeError):
-                # Private primitive unavailable — replicate load()'s default patterns.
-                from huggingface_hub import snapshot_download
-                snapshot_download(model_id, allow_patterns=_MODEL_ALLOW_PATTERNS)
-            received = _dir_size_bytes(_hf_cache_dir_for(model_id))
+            for i, spec in enumerate(specs):
+                with prefetch_lock:
+                    prefetch_state["models"][i]["state"] = "downloading"
+                with tracer.start_as_current_span("model_prefetch") as span:
+                    span.set_attribute("role", spec.role)
+                    span.set_attribute("model_id", spec.model_id)
+                    try:
+                        _download_spec(spec)
+                        received = _dir_size_bytes(_hf_cache_dir_for(spec.model_id))
+                        span.set_attribute("received_bytes", received)
+                    except Exception as exc:
+                        span.set_status(trace.Status(trace.StatusCode.ERROR, str(exc)))
+                        span.record_exception(exc)
+                        with prefetch_lock:
+                            prefetch_state["models"][i]["state"] = "error"
+                        raise
+                with prefetch_lock:
+                    row = prefetch_state["models"][i]
+                    row["received"] = received or row["total"]
+                    row["state"] = "done"
+                    prefetch_state["received"] = sum(m["received"] for m in prefetch_state["models"])
+                log.info(
+                    "server: model prefetch complete",
+                    extra={"role": spec.role, "model_id": spec.model_id, "received_bytes": received},
+                )
             with prefetch_lock:
-                prefetch_state["received"] = received or prefetch_state["total"]
+                prefetch_state["received"] = (
+                    sum(m["received"] for m in prefetch_state["models"]) or prefetch_state["total"]
+                )
                 prefetch_state["state"] = "done"
-            span.set_attribute("received_bytes", received)
-            log.info("server: model prefetch complete", extra={"model_id": model_id, "received_bytes": received})
+                prefetch_state["speed"] = 0.0
+            root.set_attribute("received_bytes", prefetch_state["received"])
+            log.info("server: all model prefetch complete", extra={"received_bytes": prefetch_state["received"]})
         except Exception as exc:  # noqa: BLE001 — report, never crash the server
             with prefetch_lock:
                 prefetch_state["state"] = "error"
                 prefetch_state["error"] = str(exc)
-            span.set_status(trace.Status(trace.StatusCode.ERROR, str(exc)))
-            log.error("server: model prefetch failed", extra={"model_id": model_id, "error": str(exc)})
+                prefetch_state["speed"] = 0.0
+            root.set_status(trace.Status(trace.StatusCode.ERROR, str(exc)))
+            log.exception("server: model prefetch failed", extra={"error": str(exc)})
 
 
 @router.post("/prefetch_model")
 async def prefetch_model() -> dict:
-    """Start the eager, spec-aware model download (idempotent). Returns current status.
+    """Start the eager, registry-driven download of all pipeline models (idempotent).
 
-    Apple Intelligence backend → nothing to download (no-op `done`). Re-POSTing
-    while `downloading`/`done` returns the live state without spawning a second
+    The model set is fixed per run (the registry), so re-POSTing while
+    `downloading`/`done` returns the live state without spawning a second
     download; an earlier `error` is retried.
+
+    On Apple Intelligence / non-MLX backends, `mlx_module` is None and there
+    are no weights to download — return `done` immediately so the wizard
+    advances without trying to prefetch.
     """
+    if app_state.get("mlx_module") is None:
+        return {"state": "done", "received": 0, "total": 0, "speed": 0.0, "error": None, "models": []}
+
     from fastapi.concurrency import run_in_threadpool
 
-    m = app_state.get("mlx_module")
-    model_id = m.MODEL_ID if m else None
-    if model_id is None:
-        return {"state": "done", "model_id": model_id, "received": 0, "total": 0, "error": None}
+    specs = list(model_registry.ALL_SPECS)
 
     with prefetch_lock:
-        # Idempotent only for the SAME model: a completed/in-flight prefetch for
-        # one model must not block starting a different one after the user changes
-        # their model preference (which changes what MODEL_ID returns).
-        same_model = prefetch_state.get("model_id") == model_id
-        if same_model and prefetch_state["state"] in ("downloading", "done"):
+        if prefetch_state["state"] in ("downloading", "done"):
             return dict(prefetch_state)  # idempotent — no duplicate downloads
-        prefetch_state.update(state="downloading", model_id=model_id, received=0, total=0, error=None)
+        _speed_state["recv"] = 0
+        _speed_state["ts"] = 0.0
+        prefetch_state.update(
+            state="downloading",
+            received=0,
+            total=0,
+            error=None,
+            speed=0.0,
+            models=[
+                {"role": s.role, "model_id": s.model_id, "loader": s.loader,
+                 "received": 0, "total": 0, "state": "pending"}
+                for s in specs
+            ],
+        )
 
-    try:
-        total = await run_in_threadpool(_prefetch_total_bytes, model_id)
-    except Exception as exc:  # noqa: BLE001 — size probe is best-effort; download still runs
-        total = 0
-        log.warning("server: prefetch size-probe failed (bar will be indeterminate)", extra={"error": str(exc)})
+    # Per-model size probe (best-effort; a failed probe just leaves that model's
+    # denominator at 0 — the download still runs). All three probes fire in
+    # parallel so pre-download latency is bounded by the slowest single HF API
+    # call rather than tripling it.
+    probe_results = await asyncio.gather(
+        *[run_in_threadpool(_spec_total_bytes, s) for s in specs],
+        return_exceptions=True,
+    )
+    totals: list[int] = []
+    for spec, r in zip(specs, probe_results, strict=True):
+        if isinstance(r, int):
+            totals.append(r)
+        else:
+            totals.append(0)
+            log.warning(
+                "server: prefetch size-probe failed (bar partially indeterminate)",
+                extra={"model_id": spec.model_id, "error": str(r)},
+            )
     with prefetch_lock:
-        prefetch_state["total"] = total
+        for i, t in enumerate(totals):
+            prefetch_state["models"][i]["total"] = t
+        prefetch_state["total"] = sum(totals)
 
-    threading.Thread(target=_run_prefetch, args=(model_id,), daemon=True).start()
-    log.info("server: model prefetch started", extra={"model_id": model_id, "total_bytes": total})
+    threading.Thread(target=_run_prefetch, args=(specs,), daemon=True).start()
+    log.info(
+        "server: model prefetch started",
+        extra={"model_count": len(specs), "total_bytes": sum(totals)},
+    )
     with prefetch_lock:
         return dict(prefetch_state)
 
 
 @router.get("/prefetch_status")
 async def prefetch_status() -> dict:
-    """Live prefetch progress. `received` is recomputed from the cache dir while downloading."""
+    """Live prefetch progress. While downloading, `received` is recomputed from the
+    on-disk cache dirs of every model so the aggregate bar advances smoothly.
+
+    The disk walk runs in a threadpool so this endpoint never blocks the event
+    loop — the wizard polls it ~1 Hz and must stay responsive even while a model
+    is downloading or loading.
+    """
+    from fastapi.concurrency import run_in_threadpool
+
     with prefetch_lock:
         st = dict(prefetch_state)
-    if st["state"] == "downloading" and st["model_id"]:
-        st["received"] = _dir_size_bytes(_hf_cache_dir_for(st["model_id"]))
+        models = list(st.get("models", []))
+    if st["state"] == "downloading" and models:
+        def _recompute() -> int:
+            # Clamp each model's on-disk bytes to its probed total: a cache
+            # populated by an earlier full-repo pull can hold more than the
+            # patterns-filtered total, which would otherwise push the bar past 100%.
+            agg = 0
+            for mrow in models:
+                size = _dir_size_bytes(_hf_cache_dir_for(mrow["model_id"]))
+                cap = mrow.get("total") or 0
+                agg += min(size, cap) if cap > 0 else size
+            return agg
+
+        agg = await run_in_threadpool(_recompute)
+        with prefetch_lock:
+            # Re-check state: _run_prefetch may have finished while the disk
+            # walk was running. If so, return the authoritative completed state.
+            if prefetch_state["state"] != "downloading":
+                st = dict(prefetch_state)
+            else:
+                st["received"] = min(agg, st["total"]) if st["total"] > 0 else agg
+
+    # Derive speed (bytes/sec) from how much `received` grew since the last poll.
+    # EMA-smoothed; decays to 0 when bytes stop flowing (delta 0) or the run ends.
+    now = time.monotonic()
+    with prefetch_lock:
+        if st["state"] == "downloading" and _speed_state["ts"] and now > _speed_state["ts"]:
+            inst = max(0, st["received"] - _speed_state["recv"]) / (now - _speed_state["ts"])
+            prev = prefetch_state.get("speed", 0.0) or 0.0
+            prefetch_state["speed"] = inst if prev == 0.0 else prev * 0.5 + inst * 0.5
+        elif st["state"] != "downloading":
+            prefetch_state["speed"] = 0.0
+        _speed_state["recv"] = st["received"]
+        _speed_state["ts"] = now
+        st["speed"] = prefetch_state["speed"]
     return st

package/services/agents/server.py

@@ -43,15 +43,6 @@ from agents.routes import (
 
 log = logging.getLogger("agents.server")
 
-# Download patterns matching mlx_lm.load()'s default fileset — used by the
-# prefetch route to size and fetch exactly what the runtime will load. Lives
-# here (not in the route module) because it is the server's view of what a
-# model "is"; routes/prefetch.py imports it lazily.
-_MODEL_ALLOW_PATTERNS = [
-    "*.json", "model*.safetensors", "*.py", "tokenizer.model",
-    "*.tiktoken", "tiktoken.model", "*.txt", "*.jsonl", "*.jinja",
-]
-
 
 # ---------------------------------------------------------------------------
 # Lifespan — model loaded lazily, evicted when idle