Update openclaw_hf/backup.py

openclaw_hf/backup.py

@@ -1757,6 +1757,8 @@ class OpenClawBackup:
         print("[PRUNE] Starting old backup cleanup...")
         print(f"[PRUNE] Retention policy: keep_count={self.config.keep_count}")
 
+        MIN_FULL_BACKUPS = 12
+
         if not hasattr(self.api, "delete_file"):
             print("[PRUNE] API does not support delete_file, skipping cleanup")
             return []
@@ -1815,12 +1817,67 @@ class OpenClawBackup:
 
         sorted_timestamps = sorted(backups_by_time.keys(), reverse=True)
 
-        if len(sorted_timestamps) <= keep_count:
+        full_backup_timestamps = []
+        incremental_backup_timestamps = []
+        for ts in sorted_timestamps:
+            archive_name = Path(backups_by_time[ts][0]).name
+            if ".part-" in archive_name:
+                base_name = archive_name.rsplit(".part-", 1)[0]
+            else:
+                base_name = archive_name
+            if base_name.endswith(".tar.gz"):
+                meta_name = base_name[:-7] + ".meta.json"
+            else:
+                meta_name = base_name + ".meta.json"
+            if path_prefix_slash:
+                meta_path = f"{path_prefix_slash}{meta_name}"
+            else:
+                meta_path = meta_name
+            if meta_path in files:
+                try:
+                    cached_meta = self._get_cached_meta(meta_path)
+                    if cached_meta is not None:
+                        meta = cached_meta
+                    else:
+                        local_meta = self._download_backup(meta_path, self.config.work_dir, repo_id=self.config.dataset_repo)
+                        with open(local_meta, "r") as f:
+                            meta = json.load(f)
+                        self._set_cached_meta(meta_path, meta)
+                    if meta.get("backup_type") == "full":
+                        full_backup_timestamps.append(ts)
+                    else:
+                        incremental_backup_timestamps.append(ts)
+                except Exception:
+                    pass
+
+        print(f"[PRUNE] Full backup timestamps identified: {len(full_backup_timestamps)}")
+        print(f"[PRUNE] Incremental backup timestamps identified: {len(incremental_backup_timestamps)}")
+
+        MIN_FULL_BACKUPS = 12
+
+        cutoff_timestamp = None
+        if len(full_backup_timestamps) >= MIN_FULL_BACKUPS:
+            cutoff_timestamp = full_backup_timestamps[MIN_FULL_BACKUPS - 1]
+            print(f"[PRUNE] Minimum {MIN_FULL_BACKUPS} full backups required, cutoff at: {cutoff_timestamp}")
+        elif full_backup_timestamps:
+            cutoff_timestamp = full_backup_timestamps[-1]
+            print(f"[PRUNE] Only {len(full_backup_timestamps)} full backups exist, oldest full backup: {cutoff_timestamp}")
+
+        timestamps_to_delete = []
+        if cutoff_timestamp is not None:
+            for ts in sorted_timestamps:
+                if ts < cutoff_timestamp:
+                    timestamps_to_delete.append(ts)
+        else:
+            timestamps_to_delete = sorted_timestamps[keep_count:]
+
+        if len(sorted_timestamps) <= keep_count and not timestamps_to_delete:
             print(f"[PRUNE] Total backups ({len(sorted_timestamps)}) <= keep_count ({keep_count}), no pruning needed")
             return []
 
-        timestamps_to_delete = sorted_timestamps[keep_count:]
-        print(f"[PRUNE] Will delete {len(timestamps_to_delete)} backup(s) older than {sorted_timestamps[keep_count-1]}")
+        if not timestamps_to_delete:
+            print(f"[PRUNE] All older backups are protected (minimum {MIN_FULL_BACKUPS} full backups required)")
+            return []
 
         # Limit batch size to avoid rate limiting (max 50 files per cleanup)
         max_files_per_cleanup = 50