Fixes.

Author: milesj

crates/cache-storage/src/helpers.rs

@@ -256,7 +256,7 @@ mod tests {
             let items: Vec<usize> = (0..120).collect();
             let batches = chunk_into_batches(items, |n| *n);
 
-            assert_eq!(item_counts(&batches), vec![40, 40, 40]);
+            assert_eq!(item_counts(&batches), vec![60, 60]);
         }
 
         #[test]

crates/cas/src/cas.rs

@@ -359,6 +359,10 @@ impl CasStore {
     fn commit_temp_file(&self, hash: &ContentHash, guard: &mut TempGuard) -> miette::Result<()> {
         let dest = self.object_path(hash);
 
+        if let Some(shard) = dest.parent() {
+            std::fs::create_dir_all(shard).into_diagnostic()?;
+        }
+
         std::fs::rename(&guard.path, &dest).into_diagnostic()?;
 
         guard.committed = true;

crates/cas/tests/cas_test.rs

@@ -349,18 +349,20 @@ mod cas {
         }
 
         #[test]
-        fn returns_false_when_already_present() {
+        fn writes_unconditionally_when_present() {
             let sandbox = create_empty_sandbox();
             let store = create_store(&sandbox);
 
             let data = b"already there";
             let hash = ContentHash::hash_bytes(data).unwrap();
 
-            // First write commits to disk.
+            // `write` is an unconditional primitive — the existence check lives
+            // in the `store_*` callers — so it commits and reports true every
+            // time, leaving no temp behind.
             assert!(store.write(&hash, data).unwrap());
-
-            // Second write short-circuits — the existence check makes it a no-op.
-            assert!(!store.write(&hash, data).unwrap());
+            assert!(store.write(&hash, data).unwrap());
+            assert!(store.contains_object(&hash));
+            assert_eq!(count_temp_files(&store), 0);
         }
     }
 
@@ -384,7 +386,7 @@ mod cas {
         }
 
         #[test]
-        fn returns_false_when_already_present() {
+        fn writes_unconditionally_when_present() {
             let sandbox = create_empty_sandbox();
             let store = create_store(&sandbox);
 
@@ -393,17 +395,18 @@ mod cas {
             std::fs::write(&source, data).unwrap();
             let hash = ContentHash::hash_bytes(data).unwrap();
 
+            // Unconditional primitive: `store_file` does the existence check, so
+            // write_file itself reflinks and commits on every call.
             assert!(store.write_file(&hash, &source).unwrap());
-
-            // Second call short-circuits on the existence check; the source
-            // is never touched again.
-            assert!(!store.write_file(&hash, &source).unwrap());
+            assert!(store.write_file(&hash, &source).unwrap());
+            assert_eq!(store.read(&hash).unwrap(), data);
         }
 
         #[test]
-        fn warm_cache_creates_no_temp_file() {
-            // Like `store_file`, an object already in the store must short
-            // circuit before any temp file is staged.
+        fn leaves_no_temp_file_behind() {
+            // The warm-cache short-circuit now lives in `store_file`; the
+            // write_file primitive always stages a temp but renames it into the
+            // store, never leaving one behind.
             let sandbox = create_empty_sandbox();
             let store = create_store(&sandbox);
 
@@ -412,15 +415,11 @@ mod cas {
             std::fs::write(&source, data).unwrap();
             let hash = ContentHash::hash_bytes(data).unwrap();
 
-            assert!(store.write_file(&hash, &source).unwrap());
-
-            std::fs::remove_dir_all(&store.temp_dir).unwrap();
+            store.write_file(&hash, &source).unwrap();
+            store.write_file(&hash, &source).unwrap();
 
-            assert!(!store.write_file(&hash, &source).unwrap());
-            assert!(
-                !store.temp_dir.exists(),
-                "warm-cache write_file must not create a temp file"
-            );
+            assert!(store.contains_object(&hash));
+            assert_eq!(count_temp_files(&store), 0);
         }
     }