fix(box): retagged/rebuilt image becomes a prunable dangling (no leak)

Re-pointing a tag at a new digest (rebuild -t foo, or tag overwrite) used to
silently overwrite the index entry, dropping the displaced image from view AND
orphaning its on-disk layout forever (a real disk leak — nothing could reach it
to delete it).

- store.put: when a reference already maps to a DIFFERENT digest that loses its
  last reference, re-key the displaced image under its digest so it survives as
  a dangling entry — visible in `images`, removable by `image prune` (which
  frees the disk). Same-digest re-puts don't spawn a spurious dangling.
- images: render a digest-keyed (dangling) reference as `<none> <none>` like
  Docker, instead of splitting the digest into repository=sha256 / tag=<hex>.

Verified on KVM: build myimg:v1, rebuild with changed content -> old shows as
<none> <none>; `image-prune --force` removes exactly it and frees 3.7 MB; the
live tag survives. New unit tests cover retag->dangling, same-digest no-op, and
the <none> <none> rendering.

Author: Roy Lin

src/cli/src/commands/images.rs

@@ -179,13 +179,19 @@ struct ImageRow {
 
 impl ImageRow {
     fn from_stored(image: &a3s_box_runtime::StoredImage) -> Self {
-        let (repository, tag) = match a3s_box_runtime::ImageReference::parse(&image.reference) {
-            Ok(r) => {
-                let repo = format!("{}/{}", r.registry, r.repository);
-                let tag = r.tag.unwrap_or_else(|| "<none>".to_string());
-                (repo, tag)
+        let (repository, tag) = if crate::image_usage::is_dangling_reference(&image.reference) {
+            // Dangling image (digest-keyed, no repo:tag) — Docker renders it as
+            // `<none> <none>` rather than splitting the digest into repo + tag.
+            ("<none>".to_string(), "<none>".to_string())
+        } else {
+            match a3s_box_runtime::ImageReference::parse(&image.reference) {
+                Ok(r) => {
+                    let repo = format!("{}/{}", r.registry, r.repository);
+                    let tag = r.tag.unwrap_or_else(|| "<none>".to_string());
+                    (repo, tag)
+                }
+                Err(_) => (image.reference.clone(), "<none>".to_string()),
             }
-            Err(_) => (image.reference.clone(), "<none>".to_string()),
         };
 
         // Format digest: "sha256:" prefix + first 12 hex chars
@@ -352,11 +358,27 @@ mod tests {
 
     #[test]
     fn test_from_stored_invalid_reference_fallback() {
-        // Empty reference should fail to parse, falling back to raw reference
+        // An empty reference is treated as dangling and rendered `<none> <none>`,
+        // matching Docker's display for untagged images.
         let stored = sample_stored("", "sha256:abc", 100);
         let row = ImageRow::from_stored(&stored);
 
-        assert_eq!(row.repository, "");
+        assert_eq!(row.repository, "<none>");
+        assert_eq!(row.tag, "<none>");
+    }
+
+    #[test]
+    fn test_from_stored_digest_keyed_dangling_renders_none_none() {
+        // A digest-keyed dangling image (displaced by a re-tag) renders as
+        // `<none> <none>`, not repository="sha256" / tag=<64-char hex>.
+        let stored = sample_stored(
+            "sha256:6c3a24f143efe95ba48765929f1cf75cef0eb96c784f85d588660440796fccbb",
+            "sha256:6c3a24f143efe95ba48765929f1cf75cef0eb96c784f85d588660440796fccbb",
+            100,
+        );
+        let row = ImageRow::from_stored(&stored);
+
+        assert_eq!(row.repository, "<none>");
         assert_eq!(row.tag, "<none>");
     }
 

src/runtime/src/oci/store.rs

@@ -150,6 +150,26 @@ impl ImageStore {
         };
 
         let mut index = self.index.write().await;
+
+        // Docker parity: if this reference already points at a DIFFERENT digest
+        // and that old digest is about to lose its last reference, keep the
+        // displaced image as a dangling entry (keyed by its digest) instead of
+        // dropping it. This makes a rebuilt/re-tagged image show up as
+        // `<none>` in `images`, be removable by `image prune`, and prevents
+        // silently orphaning its on-disk layout.
+        if let Some(old) = index.get(reference).cloned() {
+            if old.digest != digest {
+                let still_referenced = index
+                    .iter()
+                    .any(|(key, img)| key.as_str() != reference && img.digest == old.digest);
+                if !still_referenced && !index.contains_key(&old.digest) {
+                    let mut dangling = old.clone();
+                    dangling.reference = old.digest.clone();
+                    index.insert(old.digest.clone(), dangling);
+                }
+            }
+        }
+
         index.insert(reference.to_string(), stored.clone());
         drop(index);
 
@@ -463,6 +483,55 @@ mod tests {
         assert!(store.get("nginx:latest").await.is_none());
     }
 
+    #[tokio::test]
+    async fn test_retag_keeps_displaced_image_as_dangling() {
+        // Docker parity: re-pointing a tag at a new digest leaves the old image
+        // as a dangling entry (keyed by its digest), not silently dropped.
+        let tmp = TempDir::new().unwrap();
+        let store_dir = tmp.path().join("store");
+        let source_dir = tmp.path().join("source");
+        create_test_oci_layout(&source_dir);
+
+        let store = ImageStore::new(&store_dir, 10 * 1024 * 1024).unwrap();
+        store
+            .put("app:latest", "sha256:old", &source_dir)
+            .await
+            .unwrap();
+        store
+            .put("app:latest", "sha256:new", &source_dir)
+            .await
+            .unwrap();
+
+        // The tag now resolves to the new digest...
+        assert_eq!(store.get("app:latest").await.unwrap().digest, "sha256:new");
+        // ...and the displaced image survives as a digest-keyed dangling entry.
+        let dangling = store.get("sha256:old").await.unwrap();
+        assert_eq!(dangling.digest, "sha256:old");
+        assert_eq!(store.list().await.len(), 2);
+    }
+
+    #[tokio::test]
+    async fn test_reput_same_digest_does_not_create_dangling() {
+        // Re-putting the same reference at the SAME digest (e.g. pulling latest
+        // when content is unchanged) must not spawn a spurious dangling entry.
+        let tmp = TempDir::new().unwrap();
+        let store_dir = tmp.path().join("store");
+        let source_dir = tmp.path().join("source");
+        create_test_oci_layout(&source_dir);
+
+        let store = ImageStore::new(&store_dir, 10 * 1024 * 1024).unwrap();
+        store
+            .put("app:latest", "sha256:same", &source_dir)
+            .await
+            .unwrap();
+        store
+            .put("app:latest", "sha256:same", &source_dir)
+            .await
+            .unwrap();
+
+        assert_eq!(store.list().await.len(), 1);
+    }
+
     #[tokio::test]
     async fn test_remove_by_digest() {
         // CRI RemoveImage identifies the image by its ID (sha256 digest),