fixos 2.2.52__tar.gz → 2.2.54__tar.gz

{fixos-2.2.52 → fixos-2.2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixos
-Version: 2.2.52
+Version: 2.2.54
 Summary: AI-powered Linux/Windows diagnostics and repair – audio, hardware, system issues
 Home-page: https://github.com/wronai/fixos
 Author: fixos contributors

fixos-2.2.54/VERSION

@@ -0,0 +1 @@
+2.2.54

fixos-2.2.54/fixos/cli/_cleanup_docker_volumes.py

@@ -0,0 +1,221 @@
+"""Selective removal of unused (dangling) Docker volumes.
+
+Volumes hold real data, so nothing here is bulk: candidates are listed with
+name, Compose project and age, the user picks them, and each one is checked
+again right before ``docker volume rm``. ``--yes`` never selects volumes whose
+name looks like stored data (databases, git mirrors, backups, ...).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timezone
+
+import click
+
+from fixos.cli import _cleanup_space as space
+from fixos.cli._cleanup_utils import _format_bytes
+
+# Name tokens that usually mean irreplaceable data rather than a cache.
+_DATA_TOKENS = re.compile(
+    r"(?:^|[_.-])(mirror|git|gitea|onedev|repo|repos|postgres|postgresql|pg|"
+    r"mysql|mariadb|mongo|mongodb|redis|db|database|backup|backups|minio|s3|"
+    r"vault|secrets?|keycloak|grafana|prometheus|influx|elastic|opensearch|"
+    r"nextcloud|uploads|media|webui|openwebui|open-webui|n8n|storage|certs|"
+    r"letsencrypt|wordpress|mattermost|synapse|chat-history)(?:$|[_.-])",
+    re.IGNORECASE,
+)
+_INSPECT_BATCH = 100
+
+
+def _docker_lines(args: list[str], timeout: int = 30) -> list[str] | None:
+    try:
+        result = space._run_cmd(["docker", *args], timeout=timeout)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    return [line for line in result.stdout.splitlines() if line.strip()]
+
+
+def _is_unused(name: str) -> bool:
+    """Re-check right before removal: still dangling and no container (even stopped)."""
+    dangling = _docker_lines(["volume", "ls", "-q", "-f", "dangling=true", "-f", f"name=^{name}$"])
+    containers = _docker_lines(["ps", "-aq", "--filter", f"volume={name}"])
+    return dangling is not None and name in dangling and containers == []
+
+
+def _age_days(created_at: str, now: datetime) -> float | None:
+    try:
+        created = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if created.tzinfo is None:
+        created = created.replace(tzinfo=timezone.utc)
+    return (now - created).total_seconds() / 86400
+
+
+_SIZE_WORKERS = 8
+
+
+def _du_batch(command: list[str], paths: list[str]) -> dict[str, int]:
+    sizes: dict[str, int] = {}
+    try:
+        result = space._run_cmd([*command, "-sbl0", "--", *paths], timeout=300)
+    except (OSError, subprocess.TimeoutExpired):
+        return sizes
+    for record in result.stdout.split("\0"):
+        size, sep, path = record.partition("\t")
+        if sep and size.isdigit():
+            sizes[path] = int(size)
+    return sizes
+
+
+def _volume_sizes(mountpoints: list[str]) -> dict[str, int]:
+    """Sizes via ``du`` in parallel batches; root-owned volumes use ``sudo -n``.
+
+    ``sudo -n`` never prompts: without passwordless sudo the size stays unknown.
+    Unreadable mountpoints go straight to ``sudo -n``, so a partial size of an
+    unreadable directory is never reported.
+    """
+    readable = [m for m in mountpoints if os.access(m, os.R_OK | os.X_OK)]
+    privileged = [m for m in mountpoints if m not in set(readable)]
+    jobs = [(["du"], readable[i::_SIZE_WORKERS]) for i in range(_SIZE_WORKERS)]
+    jobs += [(["sudo", "-n", "du"], privileged[i::_SIZE_WORKERS]) for i in range(_SIZE_WORKERS)]
+    jobs = [(command, paths) for command, paths in jobs if paths]
+    sizes: dict[str, int] = {}
+    if not jobs:
+        return sizes
+    with ThreadPoolExecutor(max_workers=min(_SIZE_WORKERS, len(jobs))) as pool:
+        for result in pool.map(lambda job: _du_batch(*job), jobs):
+            sizes.update(result)
+    return sizes
+
+
+def _unused_volumes(
+    days: float | None, match: list[str], now: datetime | None = None
+) -> list[dict] | None:
+    names = _docker_lines(["volume", "ls", "-q", "-f", "dangling=true"])
+    if names is None:
+        return None
+    now = now or datetime.now(timezone.utc)
+    records: list[dict] = []
+    for start in range(0, len(names), _INSPECT_BATCH):
+        raw = _docker_lines(["volume", "inspect", *names[start : start + _INSPECT_BATCH]], timeout=60)
+        if raw is None:
+            return None
+        records.extend(json.loads("\n".join(raw)))
+    candidates = []
+    for record in records:
+        name = record.get("Name", "")
+        if match and not any(token.lower() in name.lower() for token in match):
+            continue
+        age = _age_days(record.get("CreatedAt", ""), now)
+        if days is not None and (age is None or age < days):
+            continue
+        labels = record.get("Labels") or {}
+        project = labels.get("com.docker.compose.project") or "(bez projektu)"
+        protected = bool(_DATA_TOKENS.search(name))
+        candidates.append(
+            {
+                "name": name,
+                "description": name,
+                "project": project,
+                "age_days": age,
+                "mountpoint": record.get("Mountpoint", ""),
+                "protected": protected,
+                "size_bytes": 0,
+                "size_known": False,
+            }
+        )
+    sizes = _volume_sizes([c["mountpoint"] for c in candidates if c["mountpoint"]])
+    for candidate in candidates:
+        if candidate["mountpoint"] in sizes:
+            candidate["size_bytes"] = sizes[candidate["mountpoint"]]
+            candidate["size_known"] = True
+        age = candidate["age_days"]
+        size = _format_bytes(candidate["size_bytes"]) if candidate["size_known"] else "rozmiar nieznany"
+        candidate["note"] = (
+            f"{candidate['project']}, {age:.0f} dni" if age is not None else candidate["project"]
+        ) + (" — wygląda na DANE, tylko ręczny wybór" if candidate["protected"] else "")
+        candidate["size_label"] = size
+    candidates.sort(key=lambda c: (c["size_known"], c["size_bytes"]), reverse=True)
+    return candidates
+
+
+def _cleanup_docker_volumes(
+    json_output: bool,
+    dry_run: bool,
+    list_only: bool,
+    yes: bool,
+    days: float | None = None,
+    match: list[str] | None = None,
+) -> None:
+    """List unused Docker volumes and remove the selected ones."""
+    candidates = _unused_volumes(days, match or [])
+    if json_output:
+        space._echo_json(
+            {
+                "error": None if candidates is not None else "docker volume ls failed",
+                "candidates": [
+                    {k: c[k] for k in ("name", "project", "age_days", "size_bytes", "size_known", "protected")}
+                    for c in candidates or []
+                ],
+            }
+        )
+        return
+    if candidates is None:
+        click.echo(click.style("Błąd: nie udało się odczytać wolumenów Dockera.", fg="red"))
+        return
+    if not candidates:
+        click.echo(click.style("Brak nieużywanych wolumenów Dockera dla podanych filtrów.", fg="green"))
+        return
+    known = sum(c["size_bytes"] for c in candidates if c["size_known"])
+    click.echo(
+        f"\n{click.style('DOCKER — nieużywane wolumeny (dane!):', fg='magenta', bold=True)} "
+        f"{len(candidates)}, znany rozmiar {_format_bytes(known)}"
+    )
+    for index, item in enumerate(candidates, 1):
+        color = "red" if item["protected"] else "yellow"
+        click.echo(
+            f"  [{index:3d}] {click.style(item['name'], fg=color)}: {item['size_label']} — {item['note']}"
+        )
+    if list_only:
+        return
+    if yes:
+        selected = [i for i, c in enumerate(candidates) if not c["protected"]]
+        skipped = len(candidates) - len(selected)
+        if skipped:
+            click.echo(f"  --yes pomija {skipped} wolumenów wyglądających na dane; wybierz je ręcznie.")
+    else:
+        selected = space._choose(candidates, "Numery wolumenów do usunięcia (np. 1,2, all)")
+    if not selected:
+        click.echo("Pominięto.")
+        return
+    if dry_run:
+        space._show_dry_run_commands([["docker", "volume", "rm", candidates[i]["name"]] for i in selected])
+        return
+    if not yes and not space._confirm_remove():
+        click.echo("Anulowano.")
+        return
+    freed = 0
+    for index in selected:
+        name = candidates[index]["name"]
+        if not _is_unused(name):
+            click.echo(f"  ⏭️ {name}: jest już używany albo nie istnieje — pominięto")
+            continue
+        try:
+            result = space._run_cmd(["docker", "volume", "rm", name], timeout=120)
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            click.echo(click.style(f"  ❌ {name}: {exc}", fg="red"))
+            continue
+        if result.returncode == 0:
+            freed += candidates[index]["size_bytes"]
+            click.echo(click.style(f"  ✅ {name}", fg="green"))
+        else:
+            click.echo(click.style(f"  ❌ {name}: {result.stderr.strip()[:120]}", fg="red"))
+    click.echo(f"Usunięto wolumeny o znanym rozmiarze łącznie {_format_bytes(freed)}.")

{fixos-2.2.52 → fixos-2.2.54}/fixos/cli/_cleanup_space.py

@@ -52,6 +52,31 @@ def _run_cmd(argv: list[str], timeout: int = 60) -> subprocess.CompletedProcess:
     return subprocess.run(argv, capture_output=True, text=True, timeout=timeout, check=False)
 
 
+_DU_BATCH = 512
+
+
+def _dir_sizes(paths: list[Path]) -> dict[str, int]:
+    """Sizes in bytes for many directories with one ``du`` per batch.
+
+    ``--count-links`` keeps each directory independent of the others, as a
+    separate ``du`` would be; NUL-terminated output survives any file name.
+    Paths missing from the result must be measured individually.
+    """
+    sizes: dict[str, int] = {}
+    for start in range(0, len(paths), _DU_BATCH):
+        batch = [str(path) for path in paths[start : start + _DU_BATCH]]
+        try:
+            result = _run_cmd(["du", "-sbl0", "--", *batch], timeout=300)
+        except (OSError, subprocess.TimeoutExpired):
+            continue
+        # du exits 1 when some subtree is unreadable but still prints totals.
+        for record in result.stdout.split("\0"):
+            size, sep, name = record.partition("\t")
+            if sep and size.isdigit():
+                sizes[name] = int(size)
+    return sizes
+
+
 def _dir_size(path: Path) -> int:
     """Return directory size in bytes (du -sb with a Python fallback)."""
     try:
@@ -876,6 +901,7 @@ def _scan_tmp(
     cutoff_seconds = days * 86400
     tmp_path = Path(tmp_dir) if tmp_dir is not None else Path("/tmp")
     candidates = []
+    directories = []
 
     if tmp_path.is_dir():
         try:
@@ -893,23 +919,29 @@ def _scan_tmp(
                     mtime = stat_val.st_mtime
                     age_seconds = now - mtime
                     if age_seconds >= cutoff_seconds:
-                        size = (
-                            stat_val.st_size if not item.is_dir() else _dir_size(item)
-                        )
+                        is_dir = stat_module.S_ISDIR(stat_val.st_mode)
                         age_days = age_seconds / 86400
                         candidates.append({
                             "description": f"{name} (wiek: {age_days:.1f} dni)",
                             "path": item,
                             "name": name,
-                            "size_bytes": size,
+                            "size_bytes": 0 if is_dir else stat_val.st_size,
                             "note": f"{age_days:.1f} dni",
                             "age_days": age_days,
                         })
+                        if is_dir:
+                            directories.append(candidates[-1])
                 except (OSError, PermissionError):
                     continue
         except (OSError, PermissionError):
             pass
 
+    # One `du` per directory meant thousands of processes on a busy /tmp.
+    sizes = _dir_sizes([c["path"] for c in directories])
+    for candidate in directories:
+        size = sizes.get(str(candidate["path"]))
+        candidate["size_bytes"] = size if size is not None else _dir_size(candidate["path"])
+
     return candidates
 
 

{fixos-2.2.52 → fixos-2.2.54}/fixos/cli/cleanup_cmd.py

@@ -14,6 +14,8 @@ import re
 
 import click
 
+from fixos.cli._cleanup_docker_volumes import _cleanup_docker_volumes
+
 # Re-export public symbols used by fixos.cli (backward-compat)
 from fixos.cli._cleanup_flatpak import _cleanup_flatpak_detailed
 from fixos.cli._cleanup_space import (
@@ -129,11 +131,7 @@ def _clean_terminal_input(value: str) -> str:
 
 def _display_service_item(svc: dict) -> None:
     """Display a single service item with details."""
-    size_str = (
-        f"{svc['size_gb']:.2f} GB"
-        if svc["size_gb"] >= 1
-        else f"{svc['size_mb']:.0f} MB"
-    )
+    size_str = _size_str(svc)
     risk = svc.get("risk_level") or ("safe" if svc["safe_to_cleanup"] else "review")
     safe_text, safe_color = _RISK_LABELS.get(risk, _RISK_LABELS["review"])
 
@@ -164,6 +162,8 @@ def _display_service_item(svc: dict) -> None:
                     )
             else:
                 click.echo(f"   Komponenty: {svc['details']['components']}")
+        elif svc["service_type"] == "docker" and svc["details"].get("fast_inventory"):
+            _display_docker_inventory(svc["details"]["fast_inventory"])
         elif svc["service_type"] == "ollama" and svc["details"].get("models"):
             models = svc["details"]["models"]
             if models:
@@ -173,6 +173,26 @@ def _display_service_item(svc: dict) -> None:
     click.echo()
 
 
+def _display_docker_inventory(inventory: dict) -> None:
+    """Show what a timed-out `docker system df` could not size."""
+    click.echo("   Docker — szybki spis (bez rozmiarów wolumenów):")
+    pairs = (
+        ("obrazy", "images", "dangling_images", "wiszących"),
+        ("kontenery", "containers", "stopped_containers", "zatrzymanych"),
+        ("wolumeny", "volumes", "dangling_volumes", "nieużywanych — dane, tylko ręcznie"),
+    )
+    for label, total_key, part_key, part_label in pairs:
+        if total_key in inventory:
+            part = inventory.get(part_key)
+            suffix = f" ({part} {part_label})" if part is not None else ""
+            click.echo(f"     • {label}: {inventory[total_key]}{suffix}")
+    if "build_cache_total_gb" in inventory:
+        click.echo(
+            f"     • cache buildów: {inventory['build_cache_total_gb']:.2f} GB "
+            f"(odzyskiwalne {inventory.get('build_cache_reclaimable_gb', 0):.2f} GB)"
+        )
+
+
 def _error_message(result: dict) -> str:
     """Human-readable failure reason, even when the command's own stderr was
     empty (e.g. suppressed with 2>/dev/null inside the cleanup command
@@ -1593,7 +1613,7 @@ def _execute_yes_cleanup(plan: dict, scanner, dry_run: bool = False) -> None:
         "Wyczyść konkretną usługę "
         "(docker, docker-all, docker-old, docker-containers, docker-networks, "
         "docker-stale-services, orphaned-projects, ollama-old, snap-old, "
-        "journal, user-cache, jetbrains, libvirt, gitive, docker-buildcache, tmp, venvs-old, "
+        "journal, user-cache, jetbrains, libvirt, gitive, docker-buildcache, docker-volumes, tmp, venvs-old, "
         "npm, ...)"
     ),
 )
@@ -1701,6 +1721,23 @@ def _execute_yes_cleanup(plan: dict, scanner, dry_run: bool = False) -> None:
         f"(domyślnie {DEFAULT_OLLAMA_OLD_UNUSED_DAYS}); pomija modele aktualnie uruchomione"
     ),
 )
+@click.option(
+    "--docker-volumes",
+    "docker_volumes",
+    is_flag=True,
+    default=False,
+    help=(
+        "Wybierz i usuń nieużywane wolumeny Dockera (nazwa, projekt Compose, wiek, "
+        "rozmiar przez du/sudo -n); filtry --days i --match; --yes pomija "
+        "wolumeny wyglądające na dane"
+    ),
+)
+@click.option(
+    "--match",
+    "match",
+    default=None,
+    help="Dla --docker-volumes: fragmenty nazw rozdzielone przecinkami, np. ollama,huggingface",
+)
 @click.option(
     "--snap-old",
     "snap_old",
@@ -1875,6 +1912,8 @@ def cleanup_services(
     list_orphan_pins,
     process_hours,
     ollama_old,
+    docker_volumes,
+    match,
     snap_old,
     journal_cleanup,
     user_cache,
@@ -1933,6 +1972,8 @@ def cleanup_services(
       fixos cleanup --unpin-orphan-project /absolute/missing/project
       # usuwa ochronę, ale nie zmienia Dockera ani procesów
       fixos cleanup --ollama-old --days 90 --dry-run
+      fixos cleanup --docker-volumes --list   # nieużywane wolumeny: nazwa, projekt, wiek, rozmiar
+      fixos cleanup --docker-volumes --match ollama,huggingface --days 90
       # modele Ollama niezmieniane od 90+ dni
       fixos cleanup -c ollama-old
       fixos cleanup --snap-old          # wyłączone rewizje snapów
@@ -1986,6 +2027,7 @@ def cleanup_services(
                 list_orphan_pins,
                 ollama_old,
                 snap_old,
+                docker_volumes,
                 journal_cleanup,
                 user_cache,
                 jetbrains,
@@ -2035,6 +2077,7 @@ def cleanup_services(
                 ollama_old,
                 docker_buildcache,
                 snap_old,
+                docker_volumes,
                 journal_cleanup,
                 user_cache,
                 jetbrains,
@@ -2088,6 +2131,17 @@ def cleanup_services(
         "libvirt": (libvirt, _cleanup_libvirt),
         "gitive": (gitive, _cleanup_gitive),
         "docker-buildcache": (docker_buildcache, _cleanup_docker_buildcache),
+        "docker-volumes": (
+            docker_volumes,
+            lambda j, d, lst, y: _cleanup_docker_volumes(
+                j,
+                d,
+                lst,
+                y,
+                days=effective_days,
+                match=[t.strip() for t in (match or "").split(",") if t.strip()],
+            ),
+        ),
         "tmp": (
             tmp_cleanup,
             lambda j, d, lst, y: _cleanup_tmp(
@@ -2150,7 +2204,7 @@ def cleanup_services(
         click.echo(
             click.style(
                 "Akcje odzyskiwania miejsca (snap/journal/cache/JetBrains/"
-                "libvirt/gitive/docker-buildcache/tmp/trash/thumbnails) uruchom jako osobną, pojedynczą akcję.",
+                "libvirt/gitive/docker-buildcache/docker-volumes/tmp/trash/thumbnails) uruchom jako osobną, pojedynczą akcję.",
                 fg="red",
             )
         )

{fixos-2.2.52 → fixos-2.2.54}/fixos/config.py

@@ -128,7 +128,8 @@ PROVIDER_DEFAULTS = {
         "description": "Cerebras – najszybsze wnioskowanie na świecie, darmowy tier",
     },
     "ollama": {
-        "base_url": "http://localhost:11434/v1",
+        # Resolved from OLLAMA_HOST at load time, see ollama_host_url().
+        "base_url": None,
         "model": "llama3.2",
         "key_env": None,
         "key_url": "https://ollama.com/download",
@@ -142,6 +143,22 @@ _OPENROUTER_MODEL_MIGRATIONS = {
 }
 
 
+DEFAULT_OLLAMA_HOST = "127.0.0.1:11434"  # nohardcode: allow NOHARDCODE-006 -- fallback when OLLAMA_HOST is unset or empty
+
+
+def ollama_host_url() -> str:
+    """Ollama server URL from ``OLLAMA_HOST`` (the variable Ollama itself reads).
+
+    Single source for every fixOS component talking to Ollama: the LLM
+    provider and model cleanup previously disagreed when OLLAMA_HOST pointed
+    to another host.
+    """
+    host = os.environ.get("OLLAMA_HOST", "").strip() or DEFAULT_OLLAMA_HOST
+    if "://" not in host:
+        host = f"http://{host}"
+    return host.rstrip("/")
+
+
 def _normalize_model_id(provider: str, model: str) -> str:
     """Normalize provider-specific model IDs without changing valid choices."""
     normalized = model.strip()
@@ -293,7 +310,12 @@ class FixOsConfig:
 
         # Base URL
         url_env_key = f"{cfg.provider.upper()}_BASE_URL"
-        cfg.base_url = base_url or os.environ.get(url_env_key) or pdef["base_url"]
+        cfg.base_url = (
+            base_url
+            or os.environ.get(url_env_key)
+            or pdef["base_url"]
+            or (f"{ollama_host_url()}/v1" if cfg.provider == "ollama" else None)
+        )
 
         # Transport Gemini: natywne API Google albo endpoint OpenAI-compatible
         cfg.gemini_transport = os.environ.get("GEMINI_TRANSPORT", "native").lower()

{fixos-2.2.52 → fixos-2.2.54}/fixos/diagnostics/_storage_container_mixin.py

@@ -3,15 +3,16 @@
 from __future__ import annotations
 
 import os
+from typing import ClassVar
 
-from fixos.diagnostics.storage_analyzer import StorageItem
 from fixos.constants import MIN_DOCKER_DANGLING_MB, MIN_PODMAN_MB
+from fixos.diagnostics.storage_analyzer import StorageItem
 
 
 class _ContainerAnalyzerMixin:
     """Mixin providing container _analyze_* methods for StorageAnalyzer."""
 
-    _DOCKER_DF_SECTIONS = {
+    _DOCKER_DF_SECTIONS: ClassVar[dict[str, str]] = {
         "Images space usage:": "images",
         "Containers space usage:": "containers",
         "Local Volumes space usage:": "volumes",
@@ -119,11 +120,14 @@ class _ContainerAnalyzerMixin:
                     size_bytes=total_docker,
                     category="containers",
                     risk="medium",
-                    cleanup_command="docker system prune -a --volumes",
+                    # Never a bulk volume prune: volumes are data and are
+                    # chosen one by one with `fixos cleanup --docker-volumes`.
+                    cleanup_command="docker builder prune --force --filter until=168h",
                     description=(
                         f"Docker łącznie: {StorageItem._format_size(total_docker)}. "
                         f"Obrazy: {total_images}, dangling: {dangling_images}. "
-                        "Uwaga: usunie wszystkie nieużywane zasoby."
+                        "Czyści cache buildów starszy niż 7 dni; wolumeny wybierz "
+                        "ręcznie przez `fixos cleanup --docker-volumes`."
                     ),
                 )
             )

{fixos-2.2.52 → fixos-2.2.54}/fixos/diagnostics/native_scan.py

@@ -69,9 +69,19 @@ def measure_tree(
 
 
 def measure_batch(
-    paths: list[Path], exclude: tuple[str, ...] = (), *, native: bool = True
+    paths: list[Path],
+    exclude: tuple[str, ...] = (),
+    *,
+    native: bool = True,
+    timeout: float = 120,
+    python_fallback: bool = True,
 ) -> dict[str, dict]:
-    """Measure multiple paths, accelerating with Rust batch measurement if available."""
+    """Measure multiple paths, accelerating with Rust batch measurement if available.
+
+    Results are keyed by the resolved path.  ``python_fallback=False`` returns
+    ``{}`` instead of an unbounded Python walk when the native batch is
+    missing, fails or exceeds ``timeout``; time-budgeted callers use it.
+    """
     if not paths:
         return {}
     if native:
@@ -84,7 +94,7 @@ def measure_batch(
                         [str(executable), "batch-measure", *abs_paths],
                         capture_output=True,
                         text=True,
-                        timeout=120,
+                        timeout=timeout,
                         check=True,
                     )
                     data = json.loads(result.stdout)
@@ -103,6 +113,8 @@ def measure_batch(
                             return res
                 except (OSError, ValueError, subprocess.SubprocessError):
                     pass
+    if not python_fallback:
+        return {}
     return {str(p.resolve()): measure_python(p, exclude) for p in paths}
 
 

{fixos-2.2.52 → fixos-2.2.54}/fixos/diagnostics/quick_snapshot.py

@@ -348,11 +348,15 @@ def _measure_caches(
             from fixos.diagnostics.native_scan import measure_batch
 
             unique_paths = list({path for _, path in jobs})
-            batch_result = measure_batch(unique_paths)
+            # The native batch had a 120 s limit and an unbounded Python
+            # fallback; on a busy disk that turned "quick" into minutes.
+            batch_result = measure_batch(
+                unique_paths, timeout=timeout * 2, python_fallback=False
+            )
             if isinstance(batch_result, dict) and batch_result:
                 unresolved_jobs: list[tuple[CacheRule, Path]] = []
                 for rule, path in jobs:
-                    m = batch_result.get(str(path))
+                    m = batch_result.get(str(path.resolve()))
                     if isinstance(m, dict) and "bytes" in m:
                         kib = (m["bytes"] + 1023) // 1024
                         measured.setdefault(rule.id, []).append((path, kib))
@@ -569,6 +573,28 @@ def _history_row(
     }
 
 
+def _fill_from_history(
+    items: list[dict[str, Any]], history: list[dict[str, Any]]
+) -> None:
+    """Show the last complete size for caches that missed the time budget.
+
+    The item stays ``complete: False`` so growth reports never compare it.
+    """
+    for item in items:
+        if item.get("complete", True):
+            continue
+        for row in reversed(history):
+            if row.get("cache_complete", {}).get(item["id"]) and item["id"] in row.get(
+                "cache_sizes", {}
+            ):
+                size = int(row["cache_sizes"][item["id"]])
+                if size > item["size_bytes"]:
+                    item["size_bytes"] = size
+                    item["size_gb"] = round(size / 1024**3, 3)
+                item["last_complete_at"] = row.get("generated_at")
+                break
+
+
 def _parse_timestamp(row: dict[str, Any]) -> datetime | None:
     try:
         parsed = datetime.fromisoformat(str(row["generated_at"]))
@@ -836,6 +862,9 @@ def collect_quick_snapshot(
     history_path = _state_dir(state_dir) / "quick-history.json"
     history = _load_history(history_path)
     current_row = _history_row(generated_at, resources, safe_items, review_items)
+    _fill_from_history(safe_items + review_items, history)
+    safe_items.sort(key=lambda item: item["size_bytes"], reverse=True)
+    review_items.sort(key=lambda item: item["size_bytes"], reverse=True)
     growth = _growth_report(history, current_row, now, max(1, hours))
     alerts = _alerts(resources, growth, thresholds)