chore(release): v2.5.0 — CoW snapshot restore + programmable-CI SDK (a3s-box-ci) (#151)

* chore(snapshot): warn when prune keeps in-use CoW lowers

When `snapshot prune`/auto-prune cannot reach its limit because the remaining
snapshots are all in use as copy-on-write overlay lowers, log a warning with the
count so operators understand why fewer were freed than requested. + a test that
prune evicts nothing when every snapshot is in use.

* chore(release): v2.5.0 — copy-on-write snapshot restore + programmable-CI SDK

Bumps the workspace to 2.5.0 (CHANGELOG [Unreleased] -> [2.5.0]). Highlights: CoW
snapshot restore (fork a warmed snapshot as an overlay mount, not a full copy), the
in-use guard for `snapshot rm`/`prune`, and the new `a3s-box-ci` pipeline SDK.

---------

Co-authored-by: Roy Lin <roylin@a3s.box>

Author: ZhiXiao-Lin

CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to A3S Box will be documented in this file.
 
 ## [Unreleased]
 
+## [2.5.0] — 2026-06-22
+
+Programmable CI on a3s-box: copy-on-write snapshot restore — fork a warmed snapshot as
+a near-instant overlay mount instead of a full rootfs copy — plus a new, dependency-free
+Rust SDK crate (`a3s-box-ci`) for writing CI pipelines as code, each step in its own
+MicroVM. No breaking API changes.
+
+### Added
+
+- **`a3s-box-ci` — programmable CI pipeline SDK.** A pipeline is a Rust program; box is
+  the execution backend (one kernel per step, exit code = pass/fail). `warm_base`
+  snapshots a warmed base once, `Base::step` forks it per step, and a content-addressed
+  `FileCache` skips unchanged steps. A thin, zero-dependency wrapper over the `a3s-box`
+  CLI; the DAG is the caller's code (no YAML, no engine).
+
 ### Changed
 
 - **Snapshot restore is now copy-on-write.** `a3s-box snapshot restore` no longer

src/Cargo.lock

@@ -23,7 +23,7 @@ resolver = "2"
 h2 = { path = "third_party/h2" }
 
 [workspace.package]
-version = "2.4.0"
+version = "2.5.0"
 edition = "2021"
 authors = ["A3S Lab Team"]
 license = "MIT"

src/Cargo.toml

@@ -263,7 +263,15 @@ impl SnapshotStore {
                 }
                 // Everything left is protected; can't prune further without
                 // breaking a live box, so stop (caller stays over the cap).
-                None => break,
+                None => {
+                    tracing::warn!(
+                        in_use = snapshots.len(),
+                        "snapshot prune kept {} in-use snapshot(s) (each referenced as a \
+                         copy-on-write overlay lower); requested limit not fully met",
+                        snapshots.len()
+                    );
+                    break;
+                }
             }
         }
 
@@ -668,6 +676,31 @@ mod tests {
         assert!(store.get("s4").unwrap().is_some());
     }
 
+    #[test]
+    fn prune_keeps_everything_when_all_in_use() {
+        let tmp = TempDir::new().unwrap();
+        let store = SnapshotStore::new(&tmp.path().join("snapshots")).unwrap();
+        let rootfs = make_rootfs(&tmp);
+        store.save(make_metadata("a", "a"), &rootfs).unwrap();
+        store.save(make_metadata("b", "b"), &rootfs).unwrap();
+
+        // Both snapshots are in use as a box's CoW overlay lower.
+        for (i, id) in ["a", "b"].iter().enumerate() {
+            let bd = tmp.path().join("boxes").join(format!("bx{i}"));
+            std::fs::create_dir_all(&bd).unwrap();
+            std::fs::write(
+                bd.join(".snapshot-lower"),
+                store.rootfs_path(id).to_string_lossy().as_bytes(),
+            )
+            .unwrap();
+        }
+
+        // Even asked to keep only 1, prune evicts nothing — both are protected.
+        let removed = store.prune(1, 0).unwrap();
+        assert!(removed.is_empty(), "in-use snapshots must never be pruned");
+        assert_eq!(store.count().unwrap(), 2);
+    }
+
     #[test]
     fn test_snapshot_save_with_empty_rootfs() {
         let tmp = TempDir::new().unwrap();