fix(prune): group by source label regardless of configured sources

Prune was branching on whether the local config had a `sources:` block:
with sources it grouped snapshots by `source_label` and applied retention
per-group; without sources it pooled every snapshot into one flat bucket
and ignored labels entirely. That broke central-server setups that run
prune against a repo populated by independent clients — the server has
no `sources:` and previous backups' labels were silently discarded.

Always use `apply_policy_by_label`. The label is intrinsic to each
snapshot (recorded at backup time), so the local config's source list
shouldn't influence the grouping. Closes #138.

Author: m3nu

crates/vykar-core/src/commands/prune.rs

@@ -4,7 +4,7 @@ use std::sync::atomic::AtomicBool;
 use chrono::Utc;
 
 use crate::config::{RetentionConfig, SourceEntry, VykarConfig};
-use crate::prune::{apply_policy, apply_policy_by_label, PruneDecision};
+use crate::prune::{apply_policy_by_label, PruneDecision};
 use vykar_types::error::{Result, VykarError};
 
 use super::list::load_snapshot_meta;
@@ -75,32 +75,24 @@ pub fn run(
                 .filter_map(|s| s.retention.as_ref().map(|r| (s.label.clone(), r.clone())))
                 .collect();
 
-            let has_sources = !sources.is_empty();
-
-            let decisions = if has_sources {
-                // Label-aware: group by source_label and apply per-source retention
-                if !config.retention.has_any_rule()
-                    && source_retentions.values().all(|r| !r.has_any_rule())
-                {
-                    return Err(VykarError::Config(
+            // Always group by source_label — labels are intrinsic to each
+            // snapshot (recorded at backup time), so retention must apply
+            // per-label regardless of whether the local config has a
+            // `sources:` block. (Issue #138.)
+            if !config.retention.has_any_rule()
+                && source_retentions.values().all(|r| !r.has_any_rule())
+            {
+                return Err(VykarError::Config(
                     "no retention rules configured — set at least one keep_* option in the retention section or per-source".into(),
                 ));
-                }
-                apply_policy_by_label(
-                    &target_snapshots,
-                    &config.retention,
-                    &source_retentions,
-                    now,
-                )?
-            } else {
-                // No sources — fall back to flat policy
-                if !config.retention.has_any_rule() {
-                    return Err(VykarError::Config(
-                    "no retention rules configured — set at least one keep_* option in the retention section".into(),
-                ));
-                }
-                apply_policy(&target_snapshots, &config.retention, now)?
-            };
+            }
+
+            let decisions = apply_policy_by_label(
+                &target_snapshots,
+                &config.retention,
+                &source_retentions,
+                now,
+            )?;
 
             // Build list output
             let mut list_entries = Vec::new();

crates/vykar-core/src/tests/prune_command.rs

@@ -112,6 +112,66 @@ fn prune_source_filter_only_prunes_matching_label() {
     assert!(names.contains(&"snap-b-1"));
 }
 
+/// Regression test for issue #138: when the local config has no `sources:`
+/// block (e.g. a central server running prune against a repo populated by
+/// other clients), prune must still group snapshots by `source_label`. Each
+/// label is its own retention bucket regardless of local config.
+#[test]
+fn prune_groups_by_label_even_without_configured_sources() {
+    let tmp = tempfile::tempdir().unwrap();
+    let repo_dir = tmp.path().join("repo");
+    let source_a = tmp.path().join("source-a");
+    let source_b = tmp.path().join("source-b");
+    std::fs::create_dir_all(&repo_dir).unwrap();
+    std::fs::create_dir_all(&source_a).unwrap();
+    std::fs::create_dir_all(&source_b).unwrap();
+    std::fs::write(source_a.join("a.txt"), b"a").unwrap();
+    std::fs::write(source_b.join("b.txt"), b"b").unwrap();
+
+    let mut config = init_repo(&repo_dir);
+    config.retention = RetentionConfig {
+        keep_last: Some(1),
+        ..RetentionConfig::default()
+    };
+
+    backup_single_source(&config, &source_a, "a", "snap-a");
+    std::thread::sleep(Duration::from_millis(2));
+    backup_single_source(&config, &source_b, "b", "snap-b");
+
+    let (stats, _) = commands::prune::run(&config, None, false, false, &[], &[], None)
+        .expect("prune should succeed without a sources block");
+
+    assert_eq!(stats.pruned, 0);
+    assert_eq!(stats.kept, 2);
+
+    let after = open_local_repo(&repo_dir);
+    let names: Vec<_> = after
+        .manifest()
+        .snapshots
+        .iter()
+        .map(|e| e.name.as_str())
+        .collect();
+    assert!(names.contains(&"snap-a"));
+    assert!(names.contains(&"snap-b"));
+}
+
+/// Without any configured sources, prune still needs a retention rule to do
+/// anything — verify the consolidated guard fires.
+#[test]
+fn prune_errors_without_retention_rules_when_sources_empty() {
+    let tmp = tempfile::tempdir().unwrap();
+    let repo_dir = tmp.path().join("repo");
+    std::fs::create_dir_all(&repo_dir).unwrap();
+
+    let config = init_repo(&repo_dir);
+    let err = commands::prune::run(&config, None, true, false, &[], &[], None)
+        .err()
+        .unwrap();
+    assert!(
+        matches!(err, VykarError::Config(msg) if msg.contains("no retention rules configured"))
+    );
+}
+
 /// When the snapshot blobs have been deleted from storage (commit point
 /// reached) but Phase 3 refcount cleanup fails, `prune::run` must return
 /// `Ok((stats, _))` with `stats.warnings` populated rather than propagating