Implemented correct fix:

- kept nodes having dirname/filename
  + the repo-relative path is reconstructed from the node names
- paths are reconstructed by joining dir + child path when needed
- write_commit_entries deletes removed dirs from `dir_hash_db` when they're removed
  + tree lookups used this so they'd return stale entries
  + **cache lookup bug**

Author: malcolmgreaves

crates/lib/src/core/v_latest/rm.rs

@@ -727,19 +727,10 @@ fn r_process_remove_dir(
     match &node.node {
         // if node is a Directory, stage it for removal
         EMerkleTreeNode::Directory(_) => {
-            // Update the dir name to the full relative path so that it
-            // matches the naming convention used by `get_node_dir_children`
-            // during commit (which joins `base_dir / name`).  Without this
-            // the remove entry has only the leaf name (e.g. "3") while the
-            // existing child is keyed by the full path ("1/2/3"), causing
-            // the HashSet::remove in `split_into_vnodes` to miss.
-            let mut updated_node = node.clone();
-            if let EMerkleTreeNode::Directory(ref mut dir_node) = updated_node.node {
-                dir_node.set_name(path.to_string_lossy().as_ref());
-            }
+            // node has the correct relative path to the dir, so no need for updates
             let staged_entry = StagedMerkleTreeNode {
                 status: StagedEntryStatus::Removed,
-                node: updated_node,
+                node: node.clone(),
             };
 
             // Write removed node to staged db

crates/lib/src/repositories/commits/commit_writer.rs

@@ -646,29 +646,52 @@ fn split_into_vnodes(
             // Overwrite the existing child
             // if add or modify, replace the child
             // if remove, remove the child
-            if let Ok(path) = child.node.maybe_path()
-                && path != Path::new("")
+            if let Ok(child_path) = child.node.maybe_path()
+                && child_path != Path::new("")
             {
+                // Staged directory entries keep only the leaf name (e.g. "3"),
+                // but existing children from `node_data_to_staged_node` use the
+                // full repo-relative path (e.g. "1/2/3"). Reconstruct the full
+                // path so that HashSet lookups (which compare via maybe_path) match.
+                let needs_prefix =
+                    !directory.as_os_str().is_empty() && !child_path.starts_with(directory);
+                let child = if needs_prefix {
+                    let full_path = directory.join(&child_path);
+                    let mut prefixed = child.clone();
+                    match &mut prefixed.node.node {
+                        EMerkleTreeNode::Directory(dn) => {
+                            dn.set_name(full_path.to_str().unwrap());
+                        }
+                        EMerkleTreeNode::File(fn_) => {
+                            fn_.set_name(full_path.to_str().unwrap());
+                        }
+                        _ => {}
+                    }
+                    prefixed
+                } else {
+                    child.clone()
+                };
+
                 match child.status {
                     StagedEntryStatus::Removed => {
                         log::debug!(
                             "removing child {:?} {:?} with {:?}",
                             child.node.node.node_type(),
-                            path,
+                            child.node.maybe_path().unwrap(),
                             child.node.maybe_path().unwrap()
                         );
-                        children.remove(child);
-                        removed_children.insert(child.to_owned());
+                        children.remove(&child);
+                        removed_children.insert(child);
                     }
                     _ => {
                         log::debug!(
                             "replacing child {:?} {:?} with {:?}",
                             child.node.node.node_type(),
-                            path,
+                            child.node.maybe_path().unwrap(),
                             child.node.maybe_path().unwrap()
                         );
                         log::debug!("replaced child {}", child.node);
-                        children.replace(child.clone());
+                        children.replace(child);
                     }
                 }
             }
@@ -829,6 +852,22 @@ fn write_commit_entries(
         &mut total_written,
     )?;
 
+    // Remove dir_hash entries for directories that were removed.
+    // The dir_hash_db was pre-populated from the previous commit, so
+    // removed directories still have stale entries that must be deleted;
+    // otherwise tree lookups will find the old subtree.
+    for (_, (_, removed_children)) in entries {
+        for child in removed_children {
+            if let EMerkleTreeNode::Directory(_) = &child.node.node {
+                if let Ok(child_path) = child.node.maybe_path() {
+                    let path_str = child_path.to_str().unwrap_or_default();
+                    log::debug!("deleting removed dir hash: {path_str:?}");
+                    str_val_db::delete(dir_hash_db, path_str)?;
+                }
+            }
+        }
+    }
+
     Ok(())
 }