Merge pull request #40 from sudolulo/dev

release: v0.6.5
2026-06-16 23:08:08 -04:00 · 2026-06-17 03:06:27 +00:00 · 2026-06-17 03:05:33 +00:00 · 2026-06-16 23:02:42 -04:00 · 2026-06-17 02:28:58 +00:00 · 2026-06-17 02:20:38 +00:00
17 changed files with 390 additions and 86 deletions
@@ -5,6 +5,7 @@ on:
  push:
    branches:
      - '**'
+      - '!main'
    paths:
      - 'pyproject.toml'
  workflow_dispatch:
@@ -7,6 +7,78 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+## [0.6.5] - 2026-06-17
+
+### Added
+
+- **Version displayed in startup banner**: winnow now prints its installed version at launch.
+
+### Fixed
+
+- **GPU image: `CUDAExecutionProvider` missing due to parallel install race**: `insightface` declares `onnxruntime` (CPU) as a dependency, causing `uv sync` to install both `onnxruntime` and `onnxruntime-gpu` in parallel — both packages claim the same `pybind11_state.so` binary. On GitHub Actions the CPU binary consistently won the race, leaving the GPU build without CUDA support at runtime despite all CUDA libraries being present. Fixed by reinstalling `onnxruntime-gpu` sequentially after `uv sync` to guarantee its GPU binary is on disk.
+
+- **GPU extra was missing three required nvidia pip packages**: `onnxruntime-gpu` 1.26.0 gates CUDA EP loading on the Python-importability of `nvidia-cuda-runtime-cu12`, `nvidia-cufft-cu12`, and `nvidia-curand-cu12`. These packages were not declared in the `gpu` extra and were absent on fresh installs, silently disabling GPU inference.
+
+- **`_handle_duplicate_people` raises `KeyError` on id-less person records**: bare `p["id"]` subscripts in the auto-merge loop and `_smaller_duplicate_ids` raised `KeyError` when Immich returned a person dict without an `id` field (e.g. unconfirmed face clusters). Fixed by using `p.get("id")` and filtering `None` from `skip_ids`.
+
+- **`_smaller_duplicate_ids` could include `None` in the skip set**: `p.get("id")` without a `None` guard populated `skip_ids` with `None`, causing `p.get("id") not in skip_ids` to pass for every id-less person, so unnamed face clusters were silently re-included in all return paths.
+
+- **`_handle_duplicate_people` dead code removed**: guards `if not survivor_id` and `if not merge_ids` became unreachable after the id-gate fix; their presence suggested they still ran.
+
+- **`_valid_people` in `jobs.py` used wrong name filter**: whitespace-only names (e.g. `"  "`) passed the `p.get("name")` truthiness check and were included in the person list. Fixed using `(p.get("name") or "").strip()` consistent with the cli.py gate.
+
+- **`interactive_configure` queued-marker check was O(N²)**: `[j for j in jobs if j["person"]["id"] == p.get("id")]` ran a full scan over jobs for every person in the display loop. Replaced with a `queued_ids` set hoisted before the loop.
+
+- **`executor.py` slot restore did not clear `min_quality_score_for_slot`**: when a replacement upload failed all retries after a deletion, `effective_count` was restored but the stale quality-score floor from the deleted file remained, blocking the next candidate from filling the slot.
+
+- **`get_immich_version` swallowed `KeyError` on unexpected schema**: bare `data["major"]` / `data["minor"]` / `data["patch"]` subscripts were silently caught by the surrounding `except Exception`, returning `None` without logging. Replaced with `.get()` calls that log a debug warning on unexpected schemas.
+
+- **Face embedding selects nearest face to crop centre, not largest by area**: a 25 % margin on the crop window can pull a larger neighbouring face into the bounding box; selecting the biggest face by area then embeds the wrong person. Centre-proximity is now used instead.
+
+- **Zero-norm face embeddings skipped before diversity selection**: InsightFace occasionally returns a zero vector for low-quality detections; zero embeddings pass deduplication with similarity 0 and score distance 1.0, causing them to be selected first as maximally diverse.
+
+- **`executor.py` slot restore did not clear `min_quality_score_for_slot`**: stale quality floor from the deleted file blocked the next candidate from filling the restored slot in quality-replacement mode.
+
+## [0.6.4] - 2026-06-17
+
+### Fixed
+
+- **Face bbox scaled to thumbnail space before quality filtering**: `assess_quality` now receives coordinates in thumbnail-pixel space rather than detection-image space. Previously, a face detected on a full-resolution image (e.g. 4000 px wide) was compared against `MIN_FACE_WIDTH` using its original pixel dimensions, causing faces that appear small on the thumbnail to pass the quality filter — and faces that appear large to be incorrectly rejected.
+
+- **`conf_array` default restored to 1.0 for faces with missing confidence**: the default was incorrectly set to 0.5, causing images with no `score` field in the Immich faces API response to receive a 1.7× FPS diversity boost and be selected ahead of genuinely high-confidence detections. The default is now 1.0 (no boost), treating missing confidence as neutral.
+
+- **`hard_weight` computed once outside FPS loop**: `conf_array` is constant after initialisation; moving the `np.where` call outside the `while` loop eliminates one O(n) numpy pass per selected image.
+
+- **`has_frigate_model` snapshot prevents mid-batch `recognize_face` calls on first run**: `effective_count` is incremented inside the upload loop, so using it as the `recognize_face` gate would incorrectly trigger scoring after the first upload on a first run. A boolean snapshot is now taken before the loop.
+
+- **`person_has_fscores` only set when tracker write succeeds**: the flag was moved outside the `try/except else` block, causing at-cap replacement to switch into Frigate-score mode even when the score was never written to the tracker — `get_most_redundant_mapped_file` then returned `None` and all replacement candidates were silently skipped. The flag is now set only in the `else` branch.
+
+- **`STRATEGY=skip` honoured before embedding and limit checks**: the strategy was silently converted to `auto` when InsightFace was available, because two early-returns in `_resolve_strategy` ran before the `strategy_map` lookup.
+
+- **`limit="auto"` preserved on first run**: switching to `limit = capacity` unconditionally caused the FPS adaptive early-stop to never fire on a person's first upload run. `limit="auto"` is now kept when `already_uploaded == 0`.
+
+- **`EmbeddingCache.get` falls back gracefully on all load errors**: a `MemoryError` during `np.load` of a cached embedding was re-raised, crashing the entire diversity-selection batch for that person. Cache-read failures of any kind now return `None` so the embedding is recomputed fresh.
+
+- **`get_people` returns `[]` when Immich sends `{"people": null}`**: `.get("people", [])` only uses the default when the key is absent, not when its value is `null`. Changed to `data.get("people") or []` so null-valued responses are handled the same as missing keys.
+
+- **`get_people` and `fetch_all_assets` guard against non-dict responses**: a proxy or CDN returning a JSON array (or other non-dict body) previously caused an `AttributeError` from `.get()`. Both functions now check `isinstance(data, dict)` and return an empty result with an error log.
+
+- **`filter_recent_assets` counts and logs assets with missing or unparseable timestamps** instead of silently dropping them.
+
+- **`_suppress_output` fd cleanup restructured**: the context manager now initialises `devnull_fd`, `saved_out`, and `saved_err` to `None` before the `try` block, so the `finally` can close only the descriptors that were successfully opened. Each `os.close` is wrapped in its own `try/except OSError` so a failed close cannot prevent subsequent descriptors from being released. `OSError` from `os.dup2` restore is logged at DEBUG rather than silently swallowed.
+
+- **`blur_score_from_image` copies the image before thumbnail resize**: `Image.thumbnail` modifies the image in-place. When the caller's image was already in RGB mode (no convert copy), the resize would have mutated the caller's object. A copy is now made when `score_img is img`.
+
+- **`imageWidth`/`imageHeight` zero-value treated as missing** in `image_processing.py`: the old `or img_w` fallback silently set `scale = 1.0` for a zero-valued dimension (correct) but also for `None` (also correct) with no distinction. The explicit `scale = img_w / meta_w if meta_w else 1.0` form matches the pattern used in the new `_scale_bbox_to_thumbnail` helper and makes the fallback intent clear.
+
+- **`_mark` and `update_frigate_count` copy before mutate**: both functions now create a shallow copy of the top-level tracker dict before assigning into `by_person`, so a failed `_save` cannot leave the in-memory cache ahead of the on-disk file.
+
+- **`reset_person` flat-list guard only warns when cleanup would have run**: the `isinstance(data[flat_key], list)` check previously emitted a warning even when `person_ids` was empty (a no-op call). The warning is now gated behind `person_ids and`, matching the guard on the cleanup branch.
+
+- **`_handle_duplicate_people` uses `p.get("id")` consistently**: all four return-path filter comprehensions and the `_smaller_duplicate_ids` set comprehension now use `.get("id")` instead of bare `p["id"]`, preventing a `KeyError` if the Immich API returns a person record without an `id` field.
+
+- **`K-Medoids` non-medoid membership test is O(1)**: `non_medoids` now filters against `set(medoids)` instead of the list, eliminating an O(k) scan per candidate on each outer iteration.
+
 ## [0.6.3] - 2026-06-16

 ### Fixed
@@ -50,7 +50,9 @@ RUN if [ "$VARIANT" = "cpu" ]; then \
    elif [ "$VARIANT" = "intel" ]; then \
        uv sync --frozen --no-dev --extra intel; \
    elif [ "$VARIANT" = "gpu" ]; then \
-        uv sync --frozen --no-dev --extra gpu; \
+        uv sync --frozen --no-dev --extra gpu && \
+        ORT_GPU_VER=$(.venv/bin/python -c "import importlib.metadata; print(importlib.metadata.version('onnxruntime-gpu'))") && \
+        uv pip install --python .venv/bin/python --no-deps --reinstall "onnxruntime-gpu==$ORT_GPU_VER"; \
    else \
        echo "Unknown VARIANT: '$VARIANT'. Must be one of: cpu, rocm, intel, gpu" >&2; \
        exit 1; \
@@ -1,6 +1,6 @@
 [project]
 name = "winnow"
-version = "0.6.3"
+version = "0.6.5"
 description = "Selects diverse, high-quality photos from Immich as training data for Frigate face recognition."
 license = "AGPL-3.0-or-later"
 requires-python = ">=3.13"
@@ -29,6 +29,9 @@ dependencies = [
 gpu   = [
    "onnxruntime-gpu>=1.23.2; sys_platform == 'linux' and platform_machine == 'x86_64'",
    "nvidia-cudnn-cu12>=9.0.0; sys_platform == 'linux' and platform_machine == 'x86_64'",
+    "nvidia-cuda-runtime-cu12>=12.0; sys_platform == 'linux' and platform_machine == 'x86_64'",
+    "nvidia-cufft-cu12>=11.0; sys_platform == 'linux' and platform_machine == 'x86_64'",
+    "nvidia-curand-cu12>=10.0; sys_platform == 'linux' and platform_machine == 'x86_64'",
 ]
 rocm  = ["onnxruntime-rocm>=1.16.0; sys_platform == 'linux' and platform_machine == 'x86_64'"]
 intel = ["onnxruntime-openvino>=1.20.0; sys_platform == 'linux' and platform_machine == 'x86_64'"]
@@ -340,6 +340,16 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/52/de/823919be3b9d0ccbf1f784035423c5f18f4267fb0123558d58b813c6ec86/nvidia_cuda_nvrtc_cu12-12.9.86-py3-none-win_amd64.whl", hash = "sha256:72972ebdcf504d69462d3bcd67e7b81edd25d0fb85a2c46d3ea3517666636349", size = 76408187, upload-time = "2025-06-05T20:12:27.819Z" },
 ]

+[[package]]
+name = "nvidia-cuda-runtime-cu12"
+version = "12.9.79"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/e0/0279bd94539fda525e0c8538db29b72a5a8495b0c12173113471d28bce78/nvidia_cuda_runtime_cu12-12.9.79-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:83469a846206f2a733db0c42e223589ab62fd2fabac4432d2f8802de4bded0a4", size = 3515012, upload-time = "2025-06-05T20:00:35.519Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/46/a92db19b8309581092a3add7e6fceb4c301a3fd233969856a8cbf042cd3c/nvidia_cuda_runtime_cu12-12.9.79-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25bba2dfb01d48a9b59ca474a1ac43c6ebf7011f1b0b8cc44f54eb6ac48a96c3", size = 3493179, upload-time = "2025-06-05T20:00:53.735Z" },
+    { url = "https://files.pythonhosted.org/packages/59/df/e7c3a360be4f7b93cee39271b792669baeb3846c58a4df6dfcf187a7ffab/nvidia_cuda_runtime_cu12-12.9.79-py3-none-win_amd64.whl", hash = "sha256:8e018af8fa02363876860388bd10ccb89eb9ab8fb0aa749aaf58430a9f7c4891", size = 3591604, upload-time = "2025-06-05T20:11:17.036Z" },
+]
+
 [[package]]
 name = "nvidia-cudnn-cu12"
 version = "9.23.1.3"
@@ -353,6 +363,39 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/75/ec/62b56fc5e8219a268c6f62c4e9fb1369ebec049512328e650d1a9a28bcc8/nvidia_cudnn_cu12-9.23.1.3-py3-none-win_amd64.whl", hash = "sha256:b874af5bfab5e1010ae88bfead14bf8e9da6b20283582288f1c05f056090a398", size = 689996767, upload-time = "2026-06-09T19:44:25.343Z" },
 ]

+[[package]]
+name = "nvidia-cufft-cu12"
+version = "11.4.1.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "platform_machine != 's390x'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/2b/76445b0af890da61b501fde30650a1a4bd910607261b209cccb5235d3daa/nvidia_cufft_cu12-11.4.1.4-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1a28c9b12260a1aa7a8fd12f5ebd82d027963d635ba82ff39a1acfa7c4c0fbcf", size = 200822453, upload-time = "2025-06-05T20:05:27.889Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f4/61e6996dd20481ee834f57a8e9dca28b1869366a135e0d42e2aa8493bdd4/nvidia_cufft_cu12-11.4.1.4-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c67884f2a7d276b4b80eb56a79322a95df592ae5e765cf1243693365ccab4e28", size = 200877592, upload-time = "2025-06-05T20:05:45.862Z" },
+    { url = "https://files.pythonhosted.org/packages/20/ee/29955203338515b940bd4f60ffdbc073428f25ef9bfbce44c9a066aedc5c/nvidia_cufft_cu12-11.4.1.4-py3-none-win_amd64.whl", hash = "sha256:8e5bfaac795e93f80611f807d42844e8e27e340e0cde270dcb6c65386d795b80", size = 200067309, upload-time = "2025-06-05T20:13:59.762Z" },
+]
+
+[[package]]
+name = "nvidia-curand-cu12"
+version = "10.3.10.19"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/1c/2a45afc614d99558d4a773fa740d8bb5471c8398eeed925fc0fcba020173/nvidia_curand_cu12-10.3.10.19-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:de663377feb1697e1d30ed587b07d5721fdd6d2015c738d7528a6002a6134d37", size = 68292066, upload-time = "2025-05-01T19:39:13.595Z" },
+    { url = "https://files.pythonhosted.org/packages/31/44/193a0e171750ca9f8320626e8a1f2381e4077a65e69e2fb9708bd479e34a/nvidia_curand_cu12-10.3.10.19-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:49b274db4780d421bd2ccd362e1415c13887c53c214f0d4b761752b8f9f6aa1e", size = 68295626, upload-time = "2025-05-01T19:39:38.885Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/98/1bd66fd09cbe1a5920cb36ba87029d511db7cca93979e635fd431ad3b6c0/nvidia_curand_cu12-10.3.10.19-py3-none-win_amd64.whl", hash = "sha256:e8129e6ac40dc123bd948e33d3e11b4aa617d87a583fa2f21b3210e90c743cde", size = 68774847, upload-time = "2025-05-01T19:48:52.93Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink-cu12"
+version = "12.9.86"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/0c/c75bbfb967457a0b7670b8ad267bfc4fffdf341c074e0a80db06c24ccfd4/nvidia_nvjitlink_cu12-12.9.86-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:e3f1171dbdc83c5932a45f0f4c99180a70de9bd2718c1ab77d14104f6d7147f9", size = 39748338, upload-time = "2025-06-05T20:10:25.613Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bc/2dcba8e70cf3115b400fef54f213bcd6715a3195eba000f8330f11e40c45/nvidia_nvjitlink_cu12-12.9.86-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:994a05ef08ef4b0b299829cde613a424382aff7efb08a7172c1fa616cc3af2ca", size = 39514880, upload-time = "2025-06-05T20:10:04.89Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/7e/2eecb277d8a98184d881fb98a738363fd4f14577a4d2d7f8264266e82623/nvidia_nvjitlink_cu12-12.9.86-py3-none-win_amd64.whl", hash = "sha256:cc6fcec260ca843c10e34c936921a1c426b351753587fdd638e8cff7b16bb9db", size = 35584936, upload-time = "2025-06-05T20:16:08.525Z" },
+]
+
 [[package]]
 name = "onnx"
 version = "1.21.0"
@@ -862,7 +905,7 @@ wheels = [

 [[package]]
 name = "winnow"
-version = "0.6.2"
+version = "0.6.4"
 source = { editable = "." }
 dependencies = [
    { name = "croniter" },
@@ -880,7 +923,10 @@ cpu = [
    { name = "onnxruntime" },
 ]
 gpu = [
+    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
    { name = "onnxruntime-gpu", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
 ]
 intel = [
@@ -901,7 +947,10 @@ requires-dist = [
    { name = "croniter", specifier = ">=5.0.2" },
    { name = "insightface", specifier = ">=0.7.3" },
    { name = "numpy", specifier = ">=2.2.6" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'gpu'", specifier = ">=12.0" },
    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'gpu'", specifier = ">=9.0.0" },
+    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'gpu'", specifier = ">=11.0" },
+    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'gpu'", specifier = ">=10.0" },
    { name = "onnxruntime", marker = "extra == 'cpu'", specifier = ">=1.23.2" },
    { name = "onnxruntime-gpu", marker = "platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'gpu'", specifier = ">=1.23.2" },
    { name = "onnxruntime-openvino", marker = "platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'intel'", specifier = ">=1.20.0" },
@@ -103,8 +103,11 @@ class EmbeddingCache:
        count = 0
        for f in os.listdir(self.cache_dir):
            if f.endswith(".npy"):
-                os.remove(os.path.join(self.cache_dir, f))
-                count += 1
+                try:
+                    os.remove(os.path.join(self.cache_dir, f))
+                    count += 1
+                except OSError:
+                    pass
        logger.info("Cleared %s cached embeddings.", count)


@@ -7,6 +7,7 @@ import sys
 from rich import print as rprint
 from rich.prompt import Confirm

+from . import __version__
 from .config import Config, _getenv_bool
 from .executor import execute_jobs, upload_to_frigate
 from .immich_api import get_immich_version, get_people, merge_people
@@ -71,7 +72,7 @@ def _handle_duplicate_people(people: list[dict]) -> list[dict]:
    by_name: dict[str, list[dict]] = defaultdict(list)
    for p in people:
        name = (p.get("name") or "").strip()
-        if name:
+        if name and p.get("id"):
            by_name[name].append(p)

    duplicates = {name: ps for name, ps in by_name.items() if len(ps) > 1}
@@ -81,19 +82,23 @@ def _handle_duplicate_people(people: list[dict]) -> list[dict]:
    def _smaller_duplicate_ids(groups: dict) -> set[str]:
        """IDs of all but the largest person in each duplicate group."""
        return {
-            p["id"]
+            pid
            for ps in groups.values()
            for p in sorted(ps, key=lambda x: x.get("assetCount", 0), reverse=True)[1:]
+            if (pid := p.get("id"))
        }

    skip_ids = _smaller_duplicate_ids(duplicates)

+    def _excl(lst: list[dict]) -> list[dict]:
+        return [p for p in lst if p.get("id") not in skip_ids]
+
    if not Config.MERGE_DUPLICATE_PEOPLE:
        rprint("\n[bold yellow]⚠  Duplicate person names detected in Immich:[/bold yellow]")
        for name, ps in sorted(duplicates.items()):
            ordered = sorted(ps, key=lambda x: x.get("assetCount", 0), reverse=True)
            entries = ", ".join(
-                f"[dim]{p['id'][:8]}…[/dim] ({p.get('assetCount', 0)} assets)"
+                f"[dim]{(p.get('id') or '?')[:8]}…[/dim] ({p.get('assetCount', 0)} assets)"
                for p in ordered
            )
            rprint(f"  [yellow]{name}[/yellow] → {len(ps)} people: {entries}")
@@ -109,20 +114,21 @@ def _handle_duplicate_people(people: list[dict]) -> list[dict]:
        )
        # Return deduplicated list — keep only the largest per name so that
        # downstream job creation never runs two jobs for the same Frigate folder.
-        return [p for p in people if p["id"] not in skip_ids]
+        return _excl(people)

    # Auto-merge: survivor = largest asset count, rest merge into it inside Immich
    merged_any = False
    for name, ps in sorted(duplicates.items()):
        ordered = sorted(ps, key=lambda x: x.get("assetCount", 0), reverse=True)
        survivor = ordered[0]
-        merge_ids = [p["id"] for p in ordered[1:]]
+        survivor_id = survivor.get("id")
+        merge_ids = [pid for p in ordered[1:] if (pid := p.get("id")) is not None]
        rprint(
            f"  [cyan]Merging {name!r} inside Immich:[/cyan] keeping "
-            f"[dim]{survivor['id'][:8]}…[/dim] ({survivor.get('assetCount', 0)} assets), "
+            f"[dim]{survivor_id[:8]}…[/dim] ({survivor.get('assetCount', 0)} assets), "
            f"absorbing {len(merge_ids)} smaller duplicate(s)..."
        )
-        if merge_people(survivor["id"], merge_ids):
+        if merge_people(survivor_id, merge_ids):
            rprint(f"  [green]✓ Merged {name!r}[/green]")
            merged_any = True
        else:
@@ -131,11 +137,22 @@ def _handle_duplicate_people(people: list[dict]) -> list[dict]:
    if merged_any:
        rprint("  [dim]Re-fetching people after merge...[/dim]")
        fresh = get_people()
+        if not fresh:
+            # Retry once: get_people() returns [] for both transient failures and
+            # auth errors (401); a second empty result strongly suggests a real failure.
+            fresh = get_people()
+        if not fresh:
+            logger.warning(
+                "Re-fetch after merge returned no people (tried twice)"
+                " — possible transient error or expired API key;"
+                " proceeding with pre-merge list. Check IMMICH_API_KEY if this recurs."
+            )
+            return _excl(people)
        # Filter out the smaller duplicate from any group whose merge failed — those
        # IDs still exist in Immich and would produce two jobs for the same folder.
        # IDs from groups that merged successfully are already gone from Immich, so
        # this filter is a no-op for them.
-        return [p for p in fresh if p.get("id") not in skip_ids]
+        return _excl(fresh)

    # All merges failed — fall back to local deduplication (keep largest per name) so
    # downstream job creation never runs two jobs for the same Frigate folder.
@@ -143,7 +160,7 @@ def _handle_duplicate_people(people: list[dict]) -> list[dict]:
        "  [yellow]All merges failed — applying local deduplication"
        " to avoid overwriting output.[/yellow]"
    )
-    return [p for p in people if p["id"] not in skip_ids]
+    return _excl(people)


 _UNSUPPORTED_VARS = [
@@ -168,12 +185,13 @@ def main() -> None:
        if trace_size:
            _handle_trace_crop(trace_size)

-        console.print(r"""
-    [bold blue]winnow[/bold blue]
+        console.print(f"""
+    [bold blue]winnow[/bold blue] [dim]v{__version__}[/dim]
    [dim]Immich -> Frigate Training Data Curator[/dim]
        """)

-        set_unsupported = [v for v in _UNSUPPORTED_VARS if os.environ.get(v)]
+        _FALSY = {"", "false", "0", "no", "off"}
+        set_unsupported = [v for v in _UNSUPPORTED_VARS if os.environ.get(v, "").strip().lower() not in _FALSY]
        if set_unsupported:
            console.print(
                f"[bold yellow]⚠  Advanced tuning vars set: "
@@ -173,7 +173,7 @@ class _Config:
                data = json.loads(config_file.read_text())
                if not self.IMMICH_URL:
                    self.IMMICH_URL = data.get("IMMICH_URL")
-                if os.getenv("OUTPUT_DIR") is None:
+                if not os.getenv("OUTPUT_DIR"):
                    self.OUTPUT_DIR = data.get("OUTPUT_DIR", self.OUTPUT_DIR)
            except (json.JSONDecodeError, OSError) as e:
                logging.warning("Failed to load config file: %s", e)
@@ -57,9 +57,9 @@ def select_diverse_assets(
    Returns:
        List of selected assets
    """
-    # Fast path: fewer assets than limit
+    # Fast path: fewer assets than limit — sort for consistent ordering with other paths
    if limit != "auto" and len(assets) <= limit:
-        return assets
+        return sorted(assets, key=lambda x: x.get("fileCreatedAt", ""))

    # Sort by creation time
    assets = sorted(assets, key=lambda x: x.get("fileCreatedAt", ""))
@@ -181,6 +181,28 @@ def _crop_face_from_thumbnail(
    return crop


+def _scale_bbox_to_thumbnail(
+    bbox: tuple[float, float, float, float],
+    img: Image.Image,
+    asset: dict,
+    person_id: str | None = None,
+) -> tuple[float, float, float, float]:
+    """Scale a face bbox from original detection-image space to thumbnail-pixel space."""
+    x1, y1, x2, y2 = bbox
+    img_w, img_h = img.size
+    for person in asset.get("people", []):
+        if person_id and person.get("id") != person_id:
+            continue
+        faces = person.get("faces", [])
+        if faces:
+            meta_w = faces[0].get("imageWidth") or 0
+            meta_h = faces[0].get("imageHeight") or 0
+            scale_x = img_w / meta_w if meta_w else 1.0
+            scale_y = img_h / meta_h if meta_h else 1.0
+            return (x1 * scale_x, y1 * scale_y, x2 * scale_x, y2 * scale_y)
+    return bbox
+
+
 # =============================================================================
 # Embedding Collection
 # =============================================================================
@@ -258,9 +280,13 @@ def _select_by_embedding(
            confidence = _get_face_confidence(asset, person_id=person_id)

            face_bbox = _get_face_bbox(asset, person_id=person_id)
+            thumbnail_bbox = (
+                _scale_bbox_to_thumbnail(face_bbox, img, asset, person_id)
+                if face_bbox is not None else None
+            )
            quality = assess_quality(
                img,
-                face_bbox=face_bbox,
+                face_bbox=thumbnail_bbox,
                confidence=confidence,
                blur_threshold=Config.BLUR_THRESHOLD,
                min_face_px=Config.MIN_FACE_WIDTH,
@@ -277,6 +303,9 @@ def _select_by_embedding(

            emb = get_embedding(embed_img, asset_id=asset["id"])
            if emb is not None:
+                if np.linalg.norm(emb) < 1e-6:
+                    logger.debug("Zero-norm embedding for asset %s, skipping", asset["id"])
+                    continue
                embeddings.append(emb)
                valid_candidates.append(asset)
                confidence_scores.append(confidence)
@@ -408,7 +437,8 @@ def _kmedoids(dist_matrix: np.ndarray, k: int, max_iter: int = 50) -> tuple[list
    for _ in range(max_iter):
        improved = False
        # Try swapping each medoid with a random non-medoid
-        non_medoids = [i for i in range(n) if i not in medoids]
+        medoid_set = set(medoids)
+        non_medoids = [i for i in range(n) if i not in medoid_set]
        if not non_medoids:
            break

@@ -483,7 +513,10 @@ def _cluster_aware_selection(
    norms = np.linalg.norm(emb_matrix, axis=1, keepdims=True)
    emb_normed = emb_matrix / np.maximum(norms, 1e-8)

-    # Build confidence weight array for hard example boosting
+    # Build confidence weight array for hard example boosting.
+    # Default to 1.0 for faces with no confidence score: treat as high-confidence
+    # (no boost) rather than hard-example territory. A missing score field should
+    # not cause these images to beat genuinely high-confidence detections in FPS.
    conf_array = np.ones(n)
    if confidence_scores:
        for i, c in enumerate(confidence_scores):
@@ -508,7 +541,6 @@ def _cluster_aware_selection(

    medoid_indices, cluster_labels = _kmedoids(dist_matrix, k)
    selected = list(medoid_indices)
-    selected_set = set(selected)

    logger.debug("Selected %s cluster medoids as initial picks.", len(selected))

@@ -522,10 +554,11 @@ def _cluster_aware_selection(
    for idx in selected:
        min_dists[idx] = -np.inf

+    # Hard example weighting: boost distance for low-confidence candidates.
+    # conf_array is constant after this point, so compute once outside the loop.
+    hard_weight = np.where(conf_array < 0.85, 1.0 + (0.85 - conf_array) * 2.0, 1.0)
+
    while len(selected) < target:
-        # Hard example weighting: boost distance for low-confidence candidates
-        # Confidence < 0.85 gets up to 1.5× distance boost
-        hard_weight = np.where(conf_array < 0.85, 1.0 + (0.85 - conf_array) * 2.0, 1.0)
        weighted_dists = min_dists * hard_weight

        best_idx = int(np.argmax(weighted_dists))
@@ -541,15 +574,19 @@ def _cluster_aware_selection(
            break

        selected.append(best_idx)
-        selected_set.add(best_idx)

        # Update min distances
        dists_to_new = dist_matrix[best_idx]
        min_dists = np.minimum(min_dists, dists_to_new)
        min_dists[best_idx] = -np.inf

-    selected_conf = [conf_array[i] for i in selected if conf_array[i] < 1.0]
-    hard_count = sum(1 for c in selected_conf if c < 0.85)
+    hard_count = sum(
+        1 for i in selected
+        if confidence_scores
+        and i < len(confidence_scores)
+        and confidence_scores[i] is not None
+        and confidence_scores[i] < 0.85
+    )
    logger.info("Selection complete: %s images (%s hard examples with confidence < 0.85).", len(selected), hard_count)

    # Slice to target: the while loop enforces this for non-auto mode, but
@@ -576,4 +613,4 @@ def _select_time_spread(assets: list, limit: int | str) -> list:
        return assets

    indices = np.linspace(0, len(assets) - 1, limit, dtype=int)
-    return [assets[i] for i in np.unique(indices)]
+    return [assets[i] for i in indices]
@@ -26,22 +26,47 @@ logger = logging.getLogger(__name__)
@contextmanager
 def _suppress_output():
    """Suppress stdout/stderr at the file-descriptor level, silencing C extension noise."""
-    devnull_fd = os.open(os.devnull, os.O_WRONLY)
-    saved_out, saved_err = os.dup(1), os.dup(2)
+    devnull_fd = None
+    saved_out = None
+    saved_err = None
    try:
+        devnull_fd = os.open(os.devnull, os.O_WRONLY)
+        saved_out = os.dup(1)
+        saved_err = os.dup(2)
        os.dup2(devnull_fd, 1)
        os.dup2(devnull_fd, 2)
        yield
    finally:
-        try:
-            os.dup2(saved_out, 1)
-        finally:
+        # Each block is a separate sequential statement. A BaseException (e.g.
+        # KeyboardInterrupt) raised inside block N would propagate past blocks N+1
+        # and N+2, leaving saved_err or devnull_fd unclosed. In CPython, KI is
+        # delivered between bytecodes, not mid-syscall; os.dup2 is a single C call
+        # and completes atomically, so this race is not realistically triggerable.
+        if saved_out is not None:
+            try:
+                os.dup2(saved_out, 1)
+            except OSError as e:
+                logger.debug("_suppress_output: failed to restore stdout fd: %s", e)
+            finally:
+                try:
+                    os.close(saved_out)
+                except OSError:
+                    pass
+        if saved_err is not None:
            try:
                os.dup2(saved_err, 2)
+            except OSError as e:
+                logger.debug("_suppress_output: failed to restore stderr fd: %s", e)
            finally:
+                try:
+                    os.close(saved_err)
+                except OSError:
+                    pass
+        if devnull_fd is not None:
+            try:
                os.close(devnull_fd)
-                os.close(saved_out)
-                os.close(saved_err)
+            except OSError:
+                pass


 # Lazy-loaded singleton
@@ -181,8 +206,9 @@ def get_face_embedding(img_pil: Image.Image) -> np.ndarray | None:
        return None

    try:
-        # InsightFace expects BGR cv2 image
-        img_bgr = cv2.cvtColor(np.asarray(img_pil), cv2.COLOR_RGB2BGR)
+        # InsightFace expects BGR cv2 image; normalise mode first so RGBA/grayscale don't
+        # raise a channel-count error inside cvtColor.
+        img_bgr = cv2.cvtColor(np.asarray(img_pil.convert("RGB")), cv2.COLOR_RGB2BGR)

        # Suppress scikit-image FutureWarning from InsightFace's face_align.py
        with warnings.catch_warnings():
@@ -192,9 +218,14 @@ def get_face_embedding(img_pil: Image.Image) -> np.ndarray | None:
        if not faces:
            return None

-        # Return embedding of largest face
-        largest = max(faces, key=lambda f: (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]))
-        return largest.embedding
+        # Return embedding of the face nearest the crop centre; a large margin can pull
+        # a bigger neighbouring face into frame, and max-by-area would pick the wrong person.
+        cx, cy = img_pil.width / 2, img_pil.height / 2
+        nearest = min(
+            faces,
+            key=lambda f: ((f.bbox[0] + f.bbox[2]) / 2 - cx) ** 2 + ((f.bbox[1] + f.bbox[3]) / 2 - cy) ** 2,
+        )
+        return nearest.embedding
    except Exception as e:
        logger.error("Error getting face embedding: %s", e)
        return None
@@ -1,6 +1,7 @@
 """Execution phase: image processing and Frigate upload."""

 import logging
+import operator
 import os
 import shutil
 from io import BytesIO
@@ -27,8 +28,10 @@ from .log_config import console
 from .quality import blur_score_from_image
 from .reconcile import enrich_asset_with_face_data, reconcile_frigate_mappings
 from .upload_tracker import (
-    UPLOAD_TRACKER_FILE,
    REJECT_TRACKER_FILE,
+    UPLOAD_TRACKER_FILE,
+    begin_batch,
+    flush_batch,
    get_lowest_quality_mapped_file,
    get_most_redundant_mapped_file,
    get_tracked_frigate_file_count,
@@ -36,8 +39,6 @@ from .upload_tracker import (
    has_frigate_scores,
    mark_rejected,
    mark_uploaded,
-    begin_batch,
-    flush_batch,
    remove_frigate_file,
    remove_frigate_files_batch,
 )
@@ -357,12 +358,16 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                        " (file(s) no longer in Frigate)[/dim]"
                    )
            effective_count = get_tracked_frigate_file_count(name)
-            pre_run_count = effective_count
            quality_replacement = job.get("config", {}).get("quality_replacement", False)
-            if Config.ENABLE_FRIGATE_SCORES and pre_run_count == 0:
+            if Config.ENABLE_FRIGATE_SCORES and effective_count == 0:
                progress.console.print(
                    f"  [dim]{name}: first run — Frigate diversity scoring will apply from the next run[/dim]"
                )
+            # Snapshot whether Frigate has a model before the upload loop starts.
+            # effective_count is incremented inside the loop on each successful upload,
+            # so using the live value would incorrectly trigger recognize_face calls
+            # mid-batch on the first run (after the first upload sets it to 1).
+            has_frigate_model = effective_count > 0
            actually_uploaded: list[tuple[str, str | None]] = []
            failed_deletes: set[str] = set()
            min_quality_score_for_slot: float | None = None
@@ -391,8 +396,8 @@ def upload_to_frigate(jobs: list[dict]) -> None:

                    # Pre-upload Frigate score — clean measurement (image not yet in training set).
                    # Called for all below-cap uploads (seeds frigate_scores for future at-cap
-                    # replacement) and for at-cap uploads when scores already exist. Skipped on
-                    # the first run (pre_run_count == 0) since Frigate has no model yet.
+                    # replacement) and for at-cap uploads when scores already exist.
+                    # Skipped when has_frigate_model is False (effective_count was 0 before the loop).
                    # recognize_face returns (face_name, score); we only use the score when the
                    # best match is for the correct person. Mismatches (or "unknown") are treated
                    # as None so a wrong-person score never drives a ceiling skip or replacement.
@@ -408,7 +413,7 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                    # rebuild-complete signal, poll it between recognize calls during replacement
                    # sequences rather than accepting stale/None scores.
                    pre_fscore: float | None = None
-                    if Config.ENABLE_FRIGATE_SCORES and pre_run_count > 0:
+                    if Config.ENABLE_FRIGATE_SCORES and has_frigate_model:
                        if not at_cap or person_has_fscores:
                            _result = recognize_face(fpath)
                            if _result is not None and (_result[0] or "").casefold() == name.casefold():
@@ -416,8 +421,8 @@ def upload_to_frigate(jobs: list[dict]) -> None:

                    # Below-cap novelty gate: skip candidates already covered by the Frigate model,
                    # including conditions learned from manually-added images winnow can't track.
-                    # pre_fscore is None on the first run (pre_run_count == 0 skips recognize_face
-                    # above), so this block never fires on the first run without an extra guard.
+                    # pre_fscore is None when effective_count == 0 (no Frigate model yet),
+                    # so this block never fires on the first run without an extra guard.
                    if not at_cap and pre_fscore is not None:
                        _ceiling = Config.FRIGATE_SCORE_CEILING
                        if _ceiling is None:
@@ -452,13 +457,13 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                            get_target = get_most_redundant_mapped_file
                            score_label, better_note = "frigate", " (more novel)"
                            no_score_msg = "Frigate recognize unavailable, skipping replacement"
-                            is_better_than = lambda c, t: c < t
+                            is_better_than = operator.lt
                        else:
                            candidate_score = score_map.get(fname)
                            get_target = get_lowest_quality_mapped_file
                            score_label, better_note = "blur", ""
                            no_score_msg = "no quality score, skipping replacement"
-                            is_better_than = lambda c, t: c > t
+                            is_better_than = operator.gt

                        if candidate_score is None:
                            progress.console.print(f"    [dim]⏭  {fname}: {no_score_msg}[/dim]")
@@ -489,7 +494,10 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                            effective_count -= 1
                            min_quality_score_for_slot = None if using_fscore else target_score
                        else:
-                            logger.warning("Failed to delete %s for %s, skipping replacement", target_frigate_file, name)
+                            logger.warning(
+                                "Failed to delete %s for %s, skipping replacement",
+                                target_frigate_file, name,
+                            )
                            failed_deletes.add(target_frigate_file)
                            progress.advance(upload_task)
                            continue
@@ -506,8 +514,7 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                                uploaded += 1
                                person_uploaded += 1
                                effective_count += 1
-                                min_quality_score_for_slot = None
-
+                                min_quality_score_for_slot = None  # for/else rollback mirrors this pair
                                asset_id = asset_map.get(fname)
                                if asset_id:
                                    try:
@@ -529,7 +536,17 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                                    else:
                                        if pre_fscore is not None:
                                            person_has_fscores = True
-                                        actually_uploaded.append((fname, asset_id))
+                                    # Always record for reconcile so the Frigate filename→asset_id
+                                    # mapping is created even when the tracker write fails.
+                                    # Trade-off: if mark_uploaded failed, asset_id is absent from
+                                    # asset_ids and scores. Consequences: (1) re-selected next run
+                                    # → Frigate duplicate; (2) excluded from quality-replacement
+                                    # candidates (_pick_mapped_file requires a scores entry);
+                                    # (3) counted toward MAX_AUTO_IMAGES cap (via frigate_files).
+                                    # The alternative — not appending — leaves the file permanently
+                                    # unmapped (reconcile never creates the frigate_files entry),
+                                    # making (2) and (3) permanent. Frigate duplicate is lesser.
+                                    actually_uploaded.append((fname, asset_id))

                                break
                            else:
@@ -590,6 +607,16 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                            progress.console.print(
                                f"    [red]✗ {fname}: {type(e).__name__} - {e} (after {max_retries} attempts)[/red]"
                            )
+                    else:
+                        # All retries exhausted without a successful upload.
+                        # Restore the slot freed by the preceding delete so the next
+                        # candidate still sees at_cap=True and must beat the replacement gate.
+                        # Also clear the quality floor — the deleted file's score no longer
+                        # represents any live Frigate file, and leaving it blocks the next
+                        # candidate from filling the restored slot.
+                        if at_cap:
+                            effective_count += 1
+                            min_quality_score_for_slot = None

                    progress.advance(upload_task)

@@ -603,11 +630,19 @@ def upload_to_frigate(jobs: list[dict]) -> None:
                try:
                    flush_batch(UPLOAD_TRACKER_FILE)
                except Exception as _flush_exc:
-                    logger.warning("flush_batch failed during cleanup — batch will be recovered on next begin_batch: %s", _flush_exc)
+                    logger.warning(
+                        "flush_batch failed during cleanup"
+                        " — batch will be recovered on next begin_batch: %s",
+                        _flush_exc,
+                    )
                try:
                    flush_batch(REJECT_TRACKER_FILE)
                except Exception as _flush_exc:
-                    logger.warning("flush_batch failed during cleanup — batch will be recovered on next begin_batch: %s", _flush_exc)
+                    logger.warning(
+                        "flush_batch failed during cleanup"
+                        " — batch will be recovered on next begin_batch: %s",
+                        _flush_exc,
+                    )

            # Batch-map Frigate filenames to asset IDs now that all uploads are done.
            if actually_uploaded and not _skip_reconcile:
@@ -92,11 +92,14 @@ def process_face_mode(
        return None

    img_w, img_h = img.size
-    meta_w = face_info.get("imageWidth") or img_w
-    meta_h = face_info.get("imageHeight") or img_h
+    meta_w = face_info.get("imageWidth") or 0
+    meta_h = face_info.get("imageHeight") or 0

-    # Scale bounding box to actual image dimensions
-    scale_x, scale_y = img_w / meta_w, img_h / meta_h
+    # Scale bounding box from detection-image space to actual image dimensions.
+    # Fall back to 1.0 if Immich omits the field — bbox is assumed to already
+    # be in image space (correct for thumbnails, wrong for full-res).
+    scale_x = img_w / meta_w if meta_w else 1.0
+    scale_y = img_h / meta_h if meta_h else 1.0
    x1 = face_info["boundingBoxX1"] * scale_x
    y1 = face_info["boundingBoxY1"] * scale_y
    x2 = face_info["boundingBoxX2"] * scale_x
@@ -39,7 +39,11 @@ def get_immich_version() -> tuple[int, int, int] | None:
        )
        if resp.ok:
            data = resp.json()
-            return (int(data["major"]), int(data["minor"]), int(data["patch"]))
+            major, minor, patch = data.get("major"), data.get("minor"), data.get("patch")
+            if major is None or minor is None or patch is None:
+                logger.debug("Unexpected Immich version schema: %s", data)
+                return None
+            return (int(major), int(minor), int(patch))
        return None
    except Exception:
        return None
@@ -57,8 +61,12 @@ def get_people() -> list[dict]:
            logger.error("Immich API key is invalid or expired (401 Unauthorized). Update API_KEY.")
            return []
        resp.raise_for_status()
-        return resp.json().get("people", [])
-    except (requests.RequestException, ValueError) as e:
+        data = resp.json()
+        if not isinstance(data, dict):
+            logger.error("Unexpected response shape from Immich /people: %r", type(data))
+            return []
+        return data.get("people") or []
+    except (requests.RequestException, ValueError, AttributeError) as e:
        logger.error("Failed to fetch people from Immich: %s", e)
        return []

@@ -118,7 +126,11 @@ def fetch_all_assets(person: dict) -> tuple[list[dict], int]:
                logger.error("Error fetching assets for %s (page %s): %s", name, page, resp.status_code)
                break

-            page_assets = resp.json().get("assets", [])
+            body = resp.json()
+            if not isinstance(body, dict):
+                logger.error("Unexpected response shape fetching assets for %s (page %s): %r", name, page, type(body))
+                break
+            page_assets = body.get("assets", [])
            # Immich ≥2.x returns {"assets": {"items": [...]}};
            # earlier versions returned {"assets": [...]} directly.
            if isinstance(page_assets, dict):
@@ -277,10 +289,11 @@ def filter_recent_assets(assets: list[dict], years: int | None = None) -> list[d

    logger.debug("Filtering assets older than %s years (%s)", years, cutoff)

-    recent, skipped = [], 0
+    recent, skipped, bad_timestamp = [], 0, 0
    for asset in assets:
        created_at_str = asset.get("fileCreatedAt")
        if not isinstance(created_at_str, str) or not created_at_str:
+            bad_timestamp += 1
            continue

        try:
@@ -291,8 +304,14 @@ def filter_recent_assets(assets: list[dict], years: int | None = None) -> list[d
            else:
                skipped += 1
        except ValueError:
+            bad_timestamp += 1
            continue

+    if bad_timestamp:
+        logger.warning(
+            "filter_recent_assets: %s asset(s) had missing or unparseable fileCreatedAt"
+            " and were excluded from the pool.", bad_timestamp
+        )
    logger.debug("Retained %s assets (filtered %s old assets).", len(recent), skipped)
    return recent

@@ -65,8 +65,14 @@ def _get_strategy_choice(has_embedding: bool) -> tuple[int | str, str]:

 def _resolve_strategy(strategy: str, has_embedding: bool) -> tuple[int | str, str]:
    """Resolve env var strategy to (limit, selection_mode) without prompts."""
+    if strategy == "skip":
+        return 0, "skip"
    if not has_embedding:
-        return _getenv_int("LIMIT", 30), "time"
+        limit = _getenv_int("LIMIT", 30)
+        if limit <= 0:
+            logger.warning("LIMIT=%s is invalid — ignoring and using default 30", limit)
+            limit = 30
+        return limit, "time"

    custom_limit = _getenv_optional_int("LIMIT")
    if custom_limit is not None:
@@ -186,13 +192,20 @@ def _configure_person(person: dict, people: list[dict]) -> dict | None:
    return job


+def _valid_people(people: list[dict]) -> list[dict]:
+    return sorted(
+        [p for p in people if (p.get("name") or "").strip() and p.get("id")],
+        key=lambda x: x["name"],
+    )
+
+
 def interactive_configure(people: list[dict]) -> list[dict]:
    """Interactive phase: select person(s), mode, and configure training strategy.

    Supports multi-person batch mode — after configuring one person,
    prompts to add another.
    """
-    valid_people = sorted([p for p in people if p.get("name")], key=lambda x: x["name"])
+    valid_people = _valid_people(people)

    if not valid_people:
        rprint("[red]No people found with names in Immich.[/red]")
@@ -203,9 +216,9 @@ def interactive_configure(people: list[dict]) -> list[dict]:
    while True:
        # Select person
        console.print("\n[bold cyan]Select Person to Train:[/bold cyan]")
+        queued_ids = {j["person"]["id"] for j in jobs}
        for idx, p in enumerate(valid_people, 1):
-            # Mark already-queued people
-            marker = " [dim](queued)[/dim]" if any(j["person"]["id"] == p["id"] for j in jobs) else ""
+            marker = " [dim](queued)[/dim]" if p.get("id") in queued_ids else ""
            console.print(f"  [bold]{idx}.[/bold] {p['name']}{marker}")

        p_choice = IntPrompt.ask("Enter Number", choices=[str(i) for i in range(1, len(valid_people) + 1)])
@@ -224,7 +237,7 @@ def interactive_configure(people: list[dict]) -> list[dict]:

 def auto_configure(people: list[dict]) -> list[dict]:
    """Non-interactive: configure jobs for all named people automatically."""
-    valid_people = sorted([p for p in people if p.get("name")], key=lambda x: x["name"])
+    valid_people = _valid_people(people)

    if not valid_people:
        rprint("[red]No people found with names in Immich.[/red]")
@@ -295,10 +308,11 @@ def auto_configure(people: list[dict]) -> list[dict]:
        # decides per-image whether to swap; any candidate could be an improvement).
        if not quality_replacement_only:
            if limit == "auto":
-                # Switch from open-ended auto to a fixed budget at remaining capacity
-                # so the diversity selector itself stops at the right count instead of
-                # selecting MAX_AUTO_IMAGES and then discarding the excess by position.
                if already_uploaded > 0:
+                    # Switch from open-ended auto to a fixed budget at remaining capacity
+                    # so the diversity selector stops at the right count instead of
+                    # selecting more than MAX_AUTO_IMAGES and overflowing the cap.
+                    # First runs keep limit="auto" so FPS adaptive early-stop can fire.
                    limit = capacity
            else:
                limit = min(limit, capacity)
@@ -155,7 +155,8 @@ def blur_score_from_image(img: Image.Image, max_dim: int = 1440) -> float | None
    try:
        score_img = img.convert("RGB") if img.mode != "RGB" else img
        if score_img.width > max_dim or score_img.height > max_dim:
-            score_img = score_img.copy()
+            if score_img is img:
+                score_img = score_img.copy()
            score_img.thumbnail((max_dim, max_dim), Image.LANCZOS)
        return _laplacian_var(np.array(score_img))
    except Exception as exc:
@@ -61,7 +61,7 @@ def reconcile_frigate_mappings(
            try:
                return float(fname.rsplit("_", 1)[-1].rsplit(".", 1)[0])
            except (ValueError, IndexError):
-                return 0.0
+                return float("inf")

        logger.debug(
            "%s: mapping %s file(s) by filename timestamp — assumes Frigate processes"
@@ -109,7 +109,11 @@ def begin_batch(filename: str) -> None:
        try:
            _write_to_disk(path, _cache[key])
        except Exception:
-            logger.warning("begin_batch: could not flush leftover deferred state for %s — partial progress may be lost", path)
+            logger.warning(
+                "begin_batch: could not flush leftover deferred state for %s"
+                " — partial progress may be lost",
+                path,
+            )
        _deferred.discard(key)
        _dirty.discard(key)
    _deferred.add(key)
@@ -162,7 +166,7 @@ def _mark(
        logger.warning("_mark called with empty person_name for asset %s — asset not recorded", asset_id)
        return
    data = _load(filename)
-    by_person = data.setdefault("by_person", {})
+    by_person = dict(data.get("by_person", {}))
    entry = _migrate_entry(by_person.get(person_name, {}))
    ids = set(entry["asset_ids"])
    ids.add(asset_id)
@@ -174,7 +178,9 @@ def _mark(
    if frigate_score is not None:
        entry["frigate_scores"][asset_id] = round(frigate_score, 4)
    by_person[person_name] = entry
-    _save(filename, data)
+    new_data = dict(data)
+    new_data["by_person"] = by_person
+    _save(filename, new_data)
    logger.debug("Marked %s in %s (%s)", asset_id, filename, person_name)


@@ -354,6 +360,8 @@ def find_by_crop_dimension(size: int) -> list[dict]:
            asset_to_frigate.setdefault(aid, fn)  # first-seen wins; plain inversion silently drops duplicates
        frigate_scores = entry.get("frigate_scores", {})
        for asset_id, dims in entry.get("crop_dims", {}).items():
+            if not isinstance(dims, (list, tuple)) or len(dims) < 2:
+                continue
            w, h = dims[0], dims[1]
            if w == size or h == size:
                results.append({
@@ -371,11 +379,13 @@ def find_by_crop_dimension(size: int) -> list[dict]:
 def update_frigate_count(person_name: str, count: int) -> None:
    """Record Frigate's authoritative training image count for a person."""
    data = _load(UPLOAD_TRACKER_FILE)
-    by_person = data.setdefault("by_person", {})
+    by_person = dict(data.get("by_person", {}))
    entry = _migrate_entry(by_person.get(person_name, {}))
    entry["frigate_count"] = count
    by_person[person_name] = entry
-    _save(UPLOAD_TRACKER_FILE, data)
+    new_data = dict(data)
+    new_data["by_person"] = by_person
+    _save(UPLOAD_TRACKER_FILE, new_data)


 def reset_all_people() -> None:
@@ -432,7 +442,13 @@ def reset_person(person_name: str) -> None:
            data["by_person"] = by_person
            flat_key = _flat_key(filename)
            person_ids = set(_get_ids(tracker_entry))
-            if person_ids and flat_key in data:
+            if person_ids and flat_key in data and not isinstance(data[flat_key], list):
+                logger.warning(
+                    "reset_person: %s has unexpected type for %s (%s) — skipping flat-list cleanup;"
+                    " all persons' legacy IDs in this field are unaffected but unreadable",
+                    filename, flat_key, type(data[flat_key]).__name__,
+                )
+            elif person_ids and flat_key in data:
                data[flat_key] = sorted(set(data[flat_key]) - person_ids)
            _save(filename, data)
            changed = True