fix: 强制推送更新 backup.py 修复逻辑

openclaw_hf/backup.py

@@ -676,16 +676,13 @@ class OpenClawBackup:
             # Skip if very low change rate AND (fewer changed files OR smaller total size) than minimum threshold
             # But still perform backup if it's a scheduled full backup
             if changed_files < self.config.dynamic_min_changed_files and estimated_size_kb < self.config.dynamic_min_changed_size_kb and not force_full_backup:
-                # Track skipped incremental backups to prevent chain gaps (persisted to file)
-                current_skipped = _load_skipped_count() + 1
-                _save_skipped_count(current_skipped)
+                current_skipped = self._load_skipped_count() + 1
+                self._save_skipped_count(current_skipped)
 
-                # Safety: if we've skipped too many incrementals in a row, force a backup anyway
-                # to maintain chain freshness and prevent potential gaps
                 max_skipped_incrementals = max(3, self.config.max_incremental_backups // 3)
                 if current_skipped >= max_skipped_incrementals:
                     print(f"[Dynamic Strategy] Too many skipped incrementals ({current_skipped}), forcing backup to maintain chain continuity")
-                    _clear_skipped_count()
+                    self._clear_skipped_count()
                 else:
                     skip_reason = f"Very low change rate ({change_rate:.1f} files/min, {changed_files} files, {estimated_size_kb:.0f}KB), skipping incremental backup ({current_skipped}/{max_skipped_incrementals})"
                     print(f"[Dynamic Strategy] {skip_reason}")
@@ -696,8 +693,7 @@ class OpenClawBackup:
                         "reason": skip_reason,
                     }
         else:
-            # Normal change rate - reset skipped counter
-            _clear_skipped_count()
+            self._clear_skipped_count()
         
         # Adjust compression based on size category
         if size_category == "large" and estimated_size_mb > 3000:
@@ -1750,20 +1746,37 @@ class OpenClawBackup:
         result = []
         for timestamp in sorted_timestamps:
             result.extend(backups_by_time[timestamp])
-        
+
         return result
 
+    def _find_meta_file_for_timestamp(self, timestamp: str, files: list, path_prefix_slash: str) -> str | None:
+        """Find the meta.json file path for a backup timestamp.
+
+        Args:
+            timestamp: The backup timestamp (e.g., "20260425-013501")
+            files: List of files in the repository
+            path_prefix_slash: Path prefix with trailing slash
+
+        Returns:
+            The meta file path if found, None otherwise
+        """
+        for path in files:
+            if not isinstance(path, str):
+                continue
+            if timestamp in path and path.endswith(".meta.json"):
+                return path
+        return None
+
     def prune_old_backups(self) -> list[str]:
         print("[PRUNE] Starting old backup cleanup...")
-        print(f"[PRUNE] Retention policy: keep_count={self.config.keep_count}")
-
-        MIN_FULL_BACKUPS = 12
+        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 []
 
         keep_count = self.config.keep_count if self.config.keep_count >= 1 else 48
+        min_full_backups = 12
 
         if not hasattr(self.api, "list_repo_files"):
             print("[PRUNE] API does not support list_repo_files, skipping cleanup")
@@ -1817,68 +1830,56 @@ class OpenClawBackup:
 
         sorted_timestamps = sorted(backups_by_time.keys(), reverse=True)
 
-        full_backup_timestamps = []
-        incremental_backup_timestamps = []
+        full_backup_timestamps = set()
         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:
+            meta_file = self._find_meta_file_for_timestamp(ts, files, path_prefix_slash)
+            if meta_file:
                 try:
-                    cached_meta = self._get_cached_meta(meta_path)
+                    cached_meta = self._get_cached_meta(meta_file)
                     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)
+                        local_meta = self._download_backup(meta_file, self.config.work_dir)
                         with open(local_meta, "r") as f:
                             meta = json.load(f)
-                        self._set_cached_meta(meta_path, meta)
+                        self._set_cached_meta(meta_file, meta)
                     if meta.get("backup_type") == "full":
-                        full_backup_timestamps.append(ts)
-                    else:
-                        incremental_backup_timestamps.append(ts)
+                        full_backup_timestamps.add(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)}")
+        print(f"[PRUNE] Identified {len(full_backup_timestamps)} full backup(s), ensuring minimum 12 are kept")
 
-        MIN_FULL_BACKUPS = 12
+        if len(full_backup_timestamps) < min_full_backups:
+            print(f"[PRUNE] Not enough full backups ({len(full_backup_timestamps)}) to meet minimum {min_full_backups}, skipping cleanup")
+            return []
 
-        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}")
+        kept_full_backups_list = sorted(full_backup_timestamps, reverse=True)[:min_full_backups]
+        kept_full_backups = set(kept_full_backups_list)
+        oldest_kept_full = kept_full_backups_list[-1] if kept_full_backups_list else None
+        print(f"[PRUNE] Will keep {len(kept_full_backups)} newest full backups: {kept_full_backups_list[:3]}...")
+        if oldest_kept_full:
+            print(f"[PRUNE] Oldest kept full backup: {oldest_kept_full}")
 
-        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:]
+        old_full_timestamps = [ts for ts in sorted_timestamps if ts in full_backup_timestamps and ts not in kept_full_backups]
 
-        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 []
+        incremental_timestamps = [ts for ts in sorted_timestamps if ts not in full_backup_timestamps]
+        timestamps_to_delete_candidates = list(reversed(old_full_timestamps))
+
+        for ts in reversed(incremental_timestamps):
+            if oldest_kept_full and ts >= oldest_kept_full:
+                continue
+            timestamps_to_delete_candidates.append(ts)
+
+        timestamps_to_delete = timestamps_to_delete_candidates[:keep_count]
 
         if not timestamps_to_delete:
-            print(f"[PRUNE] All older backups are protected (minimum {MIN_FULL_BACKUPS} full backups required)")
+            print("[PRUNE] No backups to delete after applying retention policy")
             return []
 
+        print(f"[PRUNE] Will delete {len(timestamps_to_delete)} backup(s): {len([t for t in timestamps_to_delete if t in full_backup_timestamps])} full, {len([t for t in timestamps_to_delete if t not in full_backup_timestamps])} incremental")
+        print(f"[PRUNE] Oldest backup to delete: {timestamps_to_delete[-1]}")
+
         # Limit batch size to avoid rate limiting (max 50 files per cleanup)
         max_files_per_cleanup = 50
         total_files_to_delete = 0