fix(internal): post-merge cleanups in config + settings_ui

- _read_backup_override_file now WARNING-logs unreadable / corrupt /
  non-dict override files instead of returning {} silently, mirroring
  _read_feature_flag_override_file. A user who saved a backup-config
  edit but hit a permission error or wrote a corrupt file now gets
  a log line instead of a silent revert to defaults.
- _atomic_write_json cleans up the .tmp file on OSError so a failed
  write doesn't leave a partial sibling next to the real file
  (parity with _save_feature_flags' inline tmp/rename block).
- Drop the duplicate inline _reset_global_settings import in
  _save_feature_flags — it's already at module scope after the merge.

Author: kingpanther13

src/ha_mcp/config.py

@@ -599,28 +599,66 @@ def get_backup_setting_origin(env_name: str) -> str:
 def _read_backup_override_file() -> dict[str, object]:
     """Return the contents of the auto-backup override file, or ``{}``.
 
-    Malformed JSON / missing file / unreadable file all return ``{}``
-    silently; the override file is best-effort and a corrupt file
-    should not break Settings loading. Reads are not cached — callers
-    (Settings construction, the GET endpoint) hit disk each time, which
-    is fine for a small JSON file behind a singleton-cached Settings.
+    Best-effort: a corrupt file MUST NOT break Settings loading. The
+    failure modes split into two categories that need different
+    treatment (mirrors ``_read_feature_flag_override_file``):
+
+    * **Silent**: file does not exist. The override layer is opt-in;
+      a missing file is the normal "user has never edited" state and
+      should not log.
+    * **Loud (WARNING)**: file exists but is unreadable
+      (``PermissionError``, broken filesystem) or unparseable
+      (``JSONDecodeError``). The user toggled something, the UI said
+      "Saved", and the value is silently being ignored. Without a
+      log line they have no diagnostic; with one, the sidecar/server
+      log tells them exactly what to fix.
+
+    Reads are not cached — callers (Settings construction, the GET
+    endpoint) hit disk each time, which is fine for a small JSON file
+    behind a singleton-cached Settings.
     """
+    import json
     from pathlib import Path
 
-    from .utils.data_paths import get_data_dir
+    try:
+        from .utils.data_paths import get_data_dir
 
-    path: Path = get_data_dir() / _BACKUP_OVERRIDE_FILENAME
+        path: Path = get_data_dir() / _BACKUP_OVERRIDE_FILENAME
+    except (RuntimeError, OSError):
+        # Couldn't resolve the data dir at all — user has no override
+        # file by definition. Silent.
+        return {}
     try:
         raw = path.read_text()
-    except (FileNotFoundError, OSError):
+    except FileNotFoundError:
+        return {}
+    except OSError:
+        logger.warning(
+            "Auto-backup override file at %s exists but is unreadable; "
+            "falling back to defaults. Check filesystem permissions.",
+            path,
+            exc_info=True,
+        )
         return {}
     try:
-        import json
-
         data = json.loads(raw)
     except ValueError:
+        logger.warning(
+            "Auto-backup override file at %s is not valid JSON; "
+            "falling back to defaults. Delete or fix the file to "
+            "re-enable persisted toggles.",
+            path,
+        )
         return {}
-    return data if isinstance(data, dict) else {}
+    if not isinstance(data, dict):
+        logger.warning(
+            "Auto-backup override file at %s is not a JSON object "
+            "(got %s); falling back to defaults.",
+            path,
+            type(data).__name__,
+        )
+        return {}
+    return data
 
 
 def _apply_backup_overrides(settings: "Settings") -> None:

src/ha_mcp/settings_ui.py

@@ -278,10 +278,17 @@ def _atomic_write_json(path: Path, payload: dict[str, Any]) -> None:
 
     Raises OSError on filesystem failure — same surface as the previous
     ``path.write_text`` so caller try/except shapes don't need updating.
+    On failure, the ``.tmp`` file is cleaned up so a previous partial
+    write does not accumulate next to the real file.
     """
     tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(payload, indent=2))
-    os.replace(str(tmp), str(path))
+    try:
+        tmp.write_text(json.dumps(payload, indent=2))
+        os.replace(str(tmp), str(path))
+    except OSError:
+        with contextlib.suppress(FileNotFoundError, OSError):
+            tmp.unlink()
+        raise
 
 
 def save_tool_config(config: dict[str, Any]) -> bool:
@@ -1924,7 +1931,6 @@ async def _save_feature_flags(request: Request) -> JSONResponse:
             _FEATURE_FLAG_INT_BOUNDS,
             _FEATURE_FLAG_OVERRIDE_FILENAME,
             FEATURE_FLAG_FIELDS,
-            _reset_global_settings,
             get_feature_flag_origin,
         )
         from .utils.data_paths import get_data_dir