diff --git a/.github/workflows/native-platform.yml b/.github/workflows/native-platform.yml
index 7f882fbd..5fd846aa 100644
--- a/.github/workflows/native-platform.yml
+++ b/.github/workflows/native-platform.yml
@@ -519,6 +519,34 @@ jobs:
           rpm=$(find "$bundle/rpm" -type f -name '*.rpm' -print -quit)
           test -n "$deb"
           test -n "$rpm"
+          deb_dependencies=$(dpkg-deb -f "$deb" Depends)
+          rpm_dependencies=$(rpm -qp --requires "$rpm")
+          printf 'DEB dependencies: %s\n' "$deb_dependencies"
+          printf 'RPM dependencies:\n%s\n' "$rpm_dependencies"
+          for dependency in \
+            libwebkit2gtk-4.1-0 libgtk-3-0 libc++1-18 libc++abi1-18 libunwind-18; do
+            case "$deb_dependencies" in
+              *"$dependency"*) ;;
+              *)
+                echo "DEB package is missing dependency: $dependency" >&2
+                exit 1
+                ;;
+            esac
+          done
+          for dependency in libcxx llvm-libunwind; do
+            if ! grep -Fx "$dependency" <<< "$rpm_dependencies"; then
+              echo "RPM package is missing dependency: $dependency" >&2
+              exit 1
+            fi
+          done
+          # rpmbuild derives shared-library requirements from ELF metadata.
+          # DNF resolves these SONAME capabilities to the Fedora provider packages.
+          for capability in libwebkit2gtk-4.1.so.0 libgtk-3.so.0; do
+            if ! grep -F "${capability}()" <<< "$rpm_dependencies"; then
+              echo "RPM package is missing runtime capability: ${capability}()" >&2
+              exit 1
+            fi
+          done
           dpkg-deb -x "$deb" "$scan/deb"
           rpm -Kv "$rpm"
           bsdtar -xf "$GITHUB_WORKSPACE/$rpm" -C "$scan/rpm"
diff --git a/README.md b/README.md
index 62515f09..cda5dc86 100644
--- a/README.md
+++ b/README.md
@@ -85,6 +85,14 @@ an insufficient runtime from Microsoft; silent `/S` installations perform that
 prerequisite step without a prompt. The installer does not bundle a fixed
 WebView2 runtime and does not replace a newer installed version.
 
+Linux packages use the system WebKitGTK runtime and LLVM 18 C++ runtime. The
+RPM declares `webkit2gtk4.1`, `gtk3`, `libcxx`, and `llvm-libunwind`. The DEB
+declares `libwebkit2gtk-4.1-0`, `libgtk-3-0`, `libc++1-18`, `libc++abi1-18`,
+and `libunwind-18`. Debian or Ubuntu releases that do not provide the LLVM 18
+runtime packages in their standard repositories require an appropriate LLVM
+package source before the DEB can be installed. An older generic `libc++1`
+package is not a compatible substitute.
+
 ## Command Line
 
 The CLI exposes the same image and object operations for scripts and batch
diff --git a/apps/application/include/axklib/application/image_sessions.hpp b/apps/application/include/axklib/application/image_sessions.hpp
index bfca4c67..93385e4f 100644
--- a/apps/application/include/axklib/application/image_sessions.hpp
+++ b/apps/application/include/axklib/application/image_sessions.hpp
@@ -103,12 +103,20 @@ struct ImageSessionRead {
     std::shared_ptr<void> lease;
 };
 
+struct ImagePartitionCapacity {
+    std::uint32_t allocated_clusters{};
+    std::uint32_t free_clusters{};
+    std::uint32_t cluster_size_bytes{};
+};
+
 struct ImageContentItem {
     std::string id;
     std::optional<std::string> parent_id;
     std::size_t depth{};
     std::optional<std::uint8_t> partition_index;
     std::optional<std::uint32_t> volume_directory_id;
+    std::optional<ImagePartitionCapacity> partition_capacity;
+    std::optional<std::uint64_t> size_bytes;
     std::string kind;
     std::string name;
     std::string display_name;
@@ -166,6 +174,7 @@ struct ImageObjectItem {
     std::string category_name;
     std::string entry_name;
     std::uint64_t stored_size_bytes{};
+    std::optional<std::uint64_t> size_with_dependencies_bytes;
     std::optional<WaveformMetadata> waveform;
     std::optional<SequenceMetadata> sequence;
 };
@@ -243,6 +252,7 @@ struct ImageObjectDeletionImpact {
     std::string volume_name;
     std::string role;
     std::string status;
+    bool requested{};
     bool selected{};
     std::uint64_t stored_size_bytes{};
     std::uint64_t freed_clusters{};
@@ -267,6 +277,8 @@ struct ImageObjectDeletionInspection {
     std::string image_id;
     std::uint64_t revision{};
     std::vector<std::string> target_object_ids;
+    std::vector<std::string> referrer_object_ids;
+    std::vector<std::string> cleanup_object_ids;
     std::vector<std::string> selected_object_ids;
     std::vector<ImageObjectDeletionImpact> impacts;
     std::vector<ImageObjectDeletionReference> references;
@@ -427,6 +439,7 @@ class ImageSessionManager {
     [[nodiscard]] Result<ImageObjectDeletionPlan> plan_deletion(std::string_view image_id, std::string_view owner_id,
                                                                 std::uint64_t expected_revision,
                                                                 const std::vector<std::string> &target_object_ids,
+                                                                const std::vector<std::string> &referrer_object_ids,
                                                                 const std::vector<std::string> &cleanup_object_ids);
     [[nodiscard]] Result<ImageWaveDataOrphanInspection>
     inspect_wave_data_orphans(std::string_view image_id, std::string_view owner_id, std::uint64_t expected_revision,
diff --git a/apps/application/src/image_session_inspection.cpp b/apps/application/src/image_session_inspection.cpp
index 5f08bf19..b3eec4bd 100644
--- a/apps/application/src/image_session_inspection.cpp
+++ b/apps/application/src/image_session_inspection.cpp
@@ -64,7 +64,8 @@ axk::app::Result<axk::app::ImageSessionSummary> axk::app::ImageSessionManager::i
 
 axk::app::Result<axk::app::ImageObjectDeletionPlan> axk::app::ImageSessionManager::plan_deletion(
     std::string_view image_id, std::string_view owner_id, std::uint64_t expected_revision,
-    const std::vector<std::string> &target_object_ids, const std::vector<std::string> &cleanup_object_ids) {
+    const std::vector<std::string> &target_object_ids, const std::vector<std::string> &referrer_object_ids,
+    const std::vector<std::string> &cleanup_object_ids) {
     const auto session = implementation_->owned(image_id, owner_id);
     if (!session)
         return std::unexpected(session.error());
@@ -82,6 +83,15 @@ axk::app::Result<axk::app::ImageObjectDeletionPlan> axk::app::ImageSessionManage
             return std::unexpected(session_error("object_not_found", "deletion target does not exist"));
         target_keys.push_back(found->second.key);
     }
+    std::vector<std::string> referrer_keys;
+    referrer_keys.reserve(referrer_object_ids.size());
+    for (const auto &object_id : referrer_object_ids) {
+        const auto found = (*session)->snapshots_by_id.find(object_id);
+        if (found == (*session)->snapshots_by_id.end()) {
+            return std::unexpected(session_error("object_not_found", "deletion referrer object does not exist"));
+        }
+        referrer_keys.push_back(found->second.key);
+    }
     std::vector<std::string> cleanup_keys;
     cleanup_keys.reserve(cleanup_object_ids.size());
     for (const auto &object_id : cleanup_object_ids) {
@@ -104,8 +114,10 @@ axk::app::Result<axk::app::ImageObjectDeletionPlan> axk::app::ImageSessionManage
     if (container == nullptr)
         return std::unexpected(
             session_error("image_mutation_unsupported", "object deletion requires an SFS container"));
-    const auto inspected = inspect_object_deletion(
-        *container, catalog, graph, {.target_keys = std::move(target_keys), .cleanup_keys = std::move(cleanup_keys)});
+    const auto inspected = inspect_object_deletion(*container, catalog, graph,
+                                                   {.target_keys = std::move(target_keys),
+                                                    .referrer_keys = std::move(referrer_keys),
+                                                    .cleanup_keys = std::move(cleanup_keys)});
     if (!inspected)
         return std::unexpected(session_error("deletion_invalid", inspected.error().message));
 
@@ -133,6 +145,8 @@ axk::app::Result<axk::app::ImageObjectDeletionPlan> axk::app::ImageSessionManage
     result.image_id = std::string{image_id};
     result.revision = expected_revision;
     result.target_object_ids = target_object_ids;
+    result.referrer_object_ids = referrer_object_ids;
+    result.cleanup_object_ids = cleanup_object_ids;
     result.selected_object_ids = map_keys(inspected->selected_keys);
     result.estimated_freed_bytes = inspected->estimated_freed_bytes;
     result.estimated_freed_clusters = inspected->estimated_freed_clusters;
@@ -149,6 +163,7 @@ axk::app::Result<axk::app::ImageObjectDeletionPlan> axk::app::ImageSessionManage
                                   .volume_name = impact.volume_name,
                                   .role = std::string{object_deletion_role_name(impact.role)},
                                   .status = std::string{object_deletion_status_name(impact.status)},
+                                  .requested = impact.requested,
                                   .selected = impact.selected,
                                   .stored_size_bytes = impact.stored_size_bytes,
                                   .freed_clusters = impact.freed_clusters,
diff --git a/apps/application/src/image_session_open.cpp b/apps/application/src/image_session_open.cpp
index 03093bb2..4cc5c87c 100644
--- a/apps/application/src/image_session_open.cpp
+++ b/apps/application/src/image_session_open.cpp
@@ -5,6 +5,64 @@
 
 #include <charconv>
 #include <iterator>
+#include <limits>
+#include <map>
+#include <set>
+
+#include "axklib/package_closure.hpp"
+
+namespace {
+
+std::optional<std::uint64_t>
+exact_dependency_size(const axk::ObjectSnapshot &root, const axk::RelationshipGraph &graph,
+                      const std::map<std::string, const axk::ObjectSnapshot *, std::less<>> &objects,
+                      const std::map<std::string, std::uint64_t, std::less<>> &sizes) {
+    if (root.object.header.type != axk::ObjectType::prog && root.object.header.type != axk::ObjectType::sbac &&
+        root.object.header.type != axk::ObjectType::sbnk) {
+        return std::nullopt;
+    }
+    std::set<std::string, std::less<>> visited;
+    std::set<std::string, std::less<>> active;
+    std::uint64_t total{};
+    const auto visit = [&](const auto &self, const axk::ObjectSnapshot &object) -> bool {
+        const auto has_exact_closure_payload = [&]() {
+            switch (object.object.header.type) {
+            case axk::ObjectType::prog:
+                return std::holds_alternative<axk::CurrentProg>(object.object.payload);
+            case axk::ObjectType::sbac:
+                return std::holds_alternative<axk::CurrentSbac>(object.object.payload);
+            case axk::ObjectType::sbnk:
+                return std::holds_alternative<axk::CurrentSbnk>(object.object.payload);
+            default:
+                return true;
+            }
+        };
+        if (!has_exact_closure_payload())
+            return false;
+        if (active.contains(object.key))
+            return false;
+        if (!visited.emplace(object.key).second)
+            return true;
+        const auto size = sizes.find(object.key);
+        if (size == sizes.end() || size->second > std::numeric_limits<std::uint64_t>::max() - total)
+            return false;
+        total += size->second;
+        active.emplace(object.key);
+        auto required = axk::package_internal::required_relationships(object, graph, objects);
+        if (!required)
+            return false;
+        for (const auto *relationship : *required) {
+            const auto target = relationship->target_key ? objects.find(*relationship->target_key) : objects.end();
+            if (target == objects.end() || !self(self, *target->second))
+                return false;
+        }
+        active.erase(object.key);
+        return true;
+    };
+    return visit(visit, root) ? std::optional{total} : std::nullopt;
+}
+
+} // namespace
 
 axk::app::Result<axk::app::ImageSessionSummary>
 axk::app::ImageSessionManager::open(const ImageSourceRef &source, std::string owner_id,
@@ -163,10 +221,21 @@ axk::app::ImageSessionManager::open_with_companion_sources(const ImageSourceRef
     auto graph = axk::build_relationship_graph(inventory->catalog);
     auto tree = axk::build_content_tree(*media, inventory->catalog, graph);
     std::unordered_map<std::uint8_t, std::string> partition_names;
+    std::unordered_map<std::uint8_t, ImagePartitionCapacity> partition_capacities;
     if (const auto *sfs = std::get_if<axk::Container>(&media->storage())) {
         partition_names.reserve(sfs->partitions().size());
-        for (const auto &partition : sfs->partitions())
+        partition_capacities.reserve(sfs->partitions().size());
+        for (const auto &partition : sfs->partitions()) {
             partition_names.emplace(partition.index.value, partition.name);
+            if (partition.allocation.free_space) {
+                const auto &free_space = *partition.allocation.free_space;
+                partition_capacities.emplace(
+                    partition.index.value,
+                    ImagePartitionCapacity{.allocated_clusters = free_space.allocated_cluster_count,
+                                           .free_clusters = free_space.free_cluster_count,
+                                           .cluster_size_bytes = free_space.cluster_size_bytes});
+            }
+        }
     }
 
     auto session = std::make_shared<Implementation::Session>();
@@ -193,6 +262,12 @@ axk::app::ImageSessionManager::open_with_companion_sources(const ImageSourceRef
     }
     for (const auto &descriptor : inventory->objects)
         session->descriptors_by_id.emplace(object_ids.at(descriptor.key), descriptor);
+    std::map<std::string, const axk::ObjectSnapshot *, std::less<>> objects_by_key;
+    std::map<std::string, std::uint64_t, std::less<>> sizes_by_key;
+    for (const auto &object : inventory->catalog.objects)
+        objects_by_key.emplace(object.key, &object);
+    for (const auto &descriptor : inventory->objects)
+        sizes_by_key.emplace(descriptor.key, descriptor.size);
     session->catalog_issues = inventory->catalog.issues;
     if (const auto *sfs = std::get_if<axk::Container>(&media->storage())) {
         const auto orphan_report = axk::analyze_waveform_orphans(*sfs, inventory->catalog, graph);
@@ -216,6 +291,7 @@ axk::app::ImageSessionManager::open_with_companion_sources(const ImageSourceRef
         item.name = object.object.header.name;
         item.format = object_format_name(object.object.format);
         item.stored_size_bytes = session->descriptors_by_id.at(item.id).size;
+        item.size_with_dependencies_bytes = exact_dependency_size(object, graph, objects_by_key, sizes_by_key);
         if (object.placement) {
             item.partition_index = object.partition.value;
             item.partition_name = object.placement->partition_name;
@@ -315,11 +391,20 @@ axk::app::ImageSessionManager::open_with_companion_sources(const ImageSourceRef
             const auto converted = std::from_chars(first, last, result);
             return converted.ec == std::errc{} && converted.ptr == last ? std::optional{result} : std::nullopt;
         }();
+        const auto partition_capacity = [&]() -> std::optional<ImagePartitionCapacity> {
+            if (node.node_type != "partition" || !partition_index)
+                return std::nullopt;
+            if (const auto found = partition_capacities.find(*partition_index); found != partition_capacities.end())
+                return found->second;
+            return std::nullopt;
+        }();
         ImageContentItem item{.id = id,
                               .parent_id = parent_id,
                               .depth = depth,
                               .partition_index = partition_index,
                               .volume_directory_id = volume_directory_id,
+                              .partition_capacity = partition_capacity,
+                              .size_bytes = std::nullopt,
                               .kind = node.node_type,
                               .name = canonical_name,
                               .display_name = node.display_name,
@@ -355,6 +440,18 @@ axk::app::ImageSessionManager::open_with_companion_sources(const ImageSourceRef
         std::ranges::sort(scoped_indices);
         const auto unique_end = std::ranges::unique(scoped_indices).begin();
         scoped_indices.erase(unique_end, scoped_indices.end());
+        if (session->content[item_index].kind == "volume") {
+            std::uint64_t size{};
+            const auto complete = std::ranges::all_of(scoped_indices, [&](std::size_t object_index) {
+                const auto object_size = session->objects[object_index].stored_size_bytes;
+                if (object_size > std::numeric_limits<std::uint64_t>::max() - size)
+                    return false;
+                size += object_size;
+                return true;
+            });
+            if (complete)
+                session->content[item_index].size_bytes = size;
+        }
         if (session->content[item_index].kind == "volume" && !session->content[item_index].partition_index &&
             !scoped_indices.empty()) {
             const auto inferred_partition_index = session->objects[scoped_indices.front()].partition_index;
diff --git a/apps/application/src/session_placement_operations.cpp b/apps/application/src/session_placement_operations.cpp
index 5622c37c..502aea01 100644
--- a/apps/application/src/session_placement_operations.cpp
+++ b/apps/application/src/session_placement_operations.cpp
@@ -1,5 +1,6 @@
 #include "axklib/application/session_placement_operations.hpp"
 
+#include <compare>
 #include <cstdint>
 #include <format>
 #include <map>
@@ -8,7 +9,6 @@
 #include <set>
 #include <string>
 #include <string_view>
-#include <tuple>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -33,23 +33,49 @@ struct PlacementRequest {
     std::optional<std::string> recovery_volume_name;
 };
 
+struct VolumeDeletionTarget {
+    std::uint8_t partition_index{};
+    std::string volume_name;
+
+    auto operator<=>(const VolumeDeletionTarget &) const = default;
+};
+
+struct VolumeDeletionRequest {
+    std::string image_id;
+    std::uint64_t revision{};
+    std::vector<VolumeDeletionTarget> targets;
+};
+
 axk::app::Error operation_error(std::string code, std::string message) { return {std::move(code), std::move(message)}; }
 
-axk::app::Result<std::tuple<std::string, std::uint64_t, std::uint8_t, std::string>>
-parse_volume_deletion_request(const Json &input) {
+axk::app::Result<VolumeDeletionRequest> parse_volume_deletion_request(const Json &input) {
     try {
-        const auto image_id = input.at("imageId").get<std::string>();
-        const auto revision = input.at("expectedRevision").get<std::uint64_t>();
-        const auto partition_value = input.at("partitionIndex").get<std::uint64_t>();
-        const auto volume_name = input.at("volumeName").get<std::string>();
-        if (image_id.empty() || revision == 0U || partition_value > 7U || volume_name.empty()) {
+        VolumeDeletionRequest result;
+        result.image_id = input.at("imageId").get<std::string>();
+        result.revision = input.at("expectedRevision").get<std::uint64_t>();
+        const auto &targets = input.at("targets");
+        if (result.image_id.empty() || result.revision == 0U || !targets.is_array() || targets.empty() ||
+            targets.size() > 1024U) {
             return std::unexpected(operation_error(
-                "invalid_request", "imageId, expectedRevision, partitionIndex, and volumeName are required"));
+                "invalid_request", "imageId, expectedRevision, and one or more volume targets are required"));
         }
-        return std::tuple{image_id, revision, static_cast<std::uint8_t>(partition_value), volume_name};
+        std::set<VolumeDeletionTarget> unique_targets;
+        for (const auto &target : targets) {
+            const auto partition_value = target.at("partitionIndex").get<std::uint64_t>();
+            const auto volume_name = target.at("volumeName").get<std::string>();
+            if (partition_value > 7U || volume_name.empty() || volume_name.size() > 16U) {
+                return std::unexpected(operation_error("invalid_request", "volume deletion target is invalid"));
+            }
+            const VolumeDeletionTarget parsed{static_cast<std::uint8_t>(partition_value), volume_name};
+            if (!unique_targets.insert(parsed).second) {
+                return std::unexpected(operation_error("invalid_request", "volume deletion targets must be unique"));
+            }
+            result.targets.push_back(parsed);
+        }
+        return result;
     } catch (const Json::exception &) {
         return std::unexpected(operation_error(
-            "invalid_request", "imageId, expectedRevision, partitionIndex, and volumeName are required"));
+            "invalid_request", "imageId, expectedRevision, and one or more volume targets are required"));
     }
 }
 
@@ -160,22 +186,28 @@ axk::app::Result<std::set<axk::SfsId>> resolve_volume_closure(const axk::app::Im
 
 axk::app::Result<Json> inspect_volume_deletion(axk::app::ImageSessionManager &images, std::string_view owner_id,
                                                std::string_view image_id, std::uint64_t revision,
-                                               std::uint8_t partition_index, std::string_view volume_name) {
+                                               const std::vector<VolumeDeletionTarget> &targets) {
     auto session = images.begin_read(image_id, owner_id, revision);
     if (!session)
         return std::unexpected(session.error());
 
-    auto closure = resolve_volume_closure(*session, partition_index, volume_name);
-    if (!closure)
-        return std::unexpected(closure.error());
+    std::set<std::pair<std::uint8_t, axk::SfsId>> closure;
+    Json target_json = Json::array();
+    for (const auto &target : targets) {
+        auto volume_closure = resolve_volume_closure(*session, target.partition_index, target.volume_name);
+        if (!volume_closure)
+            return std::unexpected(volume_closure.error());
+        for (const auto sfs_id : *volume_closure)
+            closure.emplace(target.partition_index, sfs_id);
+        target_json.push_back({{"partitionIndex", target.partition_index}, {"volumeName", target.volume_name}});
+    }
 
     axk::ObjectCatalog catalog;
     catalog.issues = session->catalog_issues;
-    std::map<std::string, axk::SfsId> object_ids;
+    std::map<std::string, std::pair<std::uint8_t, axk::SfsId>> object_ids;
     for (const auto *object : session->catalog_objects) {
         catalog.objects.push_back(*object);
-        if (object->partition.value == partition_index)
-            object_ids.emplace(object->key, object->sfs_id);
+        object_ids.emplace(object->key, std::pair{object->partition.value, object->sfs_id});
     }
     const auto graph = axk::build_relationship_graph(catalog);
     const auto crossing_count = std::ranges::count_if(graph.relationships, [&](const axk::Relationship &relationship) {
@@ -184,7 +216,7 @@ axk::app::Result<Json> inspect_volume_deletion(axk::app::ImageSessionManager &im
         const auto source = object_ids.find(relationship.source_key);
         const auto target = object_ids.find(*relationship.target_key);
         return source != object_ids.end() && target != object_ids.end() &&
-               closure->contains(source->second) != closure->contains(target->second);
+               closure.contains(source->second) != closure.contains(target->second);
     });
     Json blockers = Json::array();
     if (crossing_count != 0U) {
@@ -194,8 +226,7 @@ axk::app::Result<Json> inspect_volume_deletion(axk::app::ImageSessionManager &im
     }
     return Json{{"imageId", image_id},
                 {"revision", revision},
-                {"partitionIndex", partition_index},
-                {"volumeName", volume_name},
+                {"targets", std::move(target_json)},
                 {"canDelete", crossing_count == 0U},
                 {"crossingRelationshipCount", crossing_count},
                 {"blockers", std::move(blockers)}};
@@ -277,9 +308,8 @@ axk::app::Result<void> axk::app::bind_session_placement_operations(OperationRegi
                                        auto request = parse_volume_deletion_request(input);
                                        if (!request)
                                            return std::unexpected(request.error());
-                                       const auto &[image_id, revision, partition, volume] = *request;
-                                       return inspect_volume_deletion(images, context.owner_id, image_id, revision,
-                                                                      partition, volume);
+                                       return inspect_volume_deletion(images, context.owner_id, request->image_id,
+                                                                      request->revision, request->targets);
                                    });
         if (!bound)
             return bound;
diff --git a/apps/application/src/session_write_operations.cpp b/apps/application/src/session_write_operations.cpp
index 8e623533..3b669047 100644
--- a/apps/application/src/session_write_operations.cpp
+++ b/apps/application/src/session_write_operations.cpp
@@ -215,15 +215,16 @@ axk::app::Result<void> axk::app::bind_session_write_operations(OperationRegistry
                     const auto image_id = input.at("imageId").get<std::string>();
                     const auto revision = input.at("expectedRevision").get<std::uint64_t>();
                     const auto targets = input.at("targetObjectIds").get<std::vector<std::string>>();
+                    const auto referrers = input.at("referrerObjectIds").get<std::vector<std::string>>();
                     const auto cleanup = input.at("cleanupObjectIds").get<std::vector<std::string>>();
-                    auto plan = images.plan_deletion(image_id, context.owner_id, revision, targets, cleanup);
+                    auto plan = images.plan_deletion(image_id, context.owner_id, revision, targets, referrers, cleanup);
                     if (!plan)
                         return std::unexpected(plan.error());
                     return deletion_inspection_json(plan->inspection);
                 } catch (const Json::exception &) {
-                    return std::unexpected(operation_error(
-                        "invalid_request",
-                        "imageId, expectedRevision, targetObjectIds, and cleanupObjectIds are required"));
+                    return std::unexpected(operation_error("invalid_request",
+                                                           "imageId, expectedRevision, targetObjectIds, "
+                                                           "referrerObjectIds, and cleanupObjectIds are required"));
                 }
             });
         if (!bound)
@@ -331,18 +332,20 @@ axk::app::Result<void> axk::app::bind_session_write_operations(OperationRegistry
                 std::string image_id;
                 std::uint64_t revision{};
                 std::vector<std::string> targets;
+                std::vector<std::string> referrers;
                 std::vector<std::string> cleanup;
                 try {
                     image_id = input.at("imageId").get<std::string>();
                     revision = input.at("expectedRevision").get<std::uint64_t>();
                     targets = input.at("targetObjectIds").get<std::vector<std::string>>();
+                    referrers = input.at("referrerObjectIds").get<std::vector<std::string>>();
                     cleanup = input.at("cleanupObjectIds").get<std::vector<std::string>>();
                 } catch (const Json::exception &) {
-                    return std::unexpected(operation_error(
-                        "invalid_request",
-                        "imageId, expectedRevision, targetObjectIds, and cleanupObjectIds are required"));
+                    return std::unexpected(operation_error("invalid_request",
+                                                           "imageId, expectedRevision, targetObjectIds, "
+                                                           "referrerObjectIds, and cleanupObjectIds are required"));
                 }
-                auto plan = images.plan_deletion(image_id, context.owner_id, revision, targets, cleanup);
+                auto plan = images.plan_deletion(image_id, context.owner_id, revision, targets, referrers, cleanup);
                 if (!plan)
                     return std::unexpected(plan.error());
                 if (!plan->inspection.can_apply) {
diff --git a/apps/application/src/write_manifest_support.cpp b/apps/application/src/write_manifest_support.cpp
index 02f10a1f..7cef08f7 100644
--- a/apps/application/src/write_manifest_support.cpp
+++ b/apps/application/src/write_manifest_support.cpp
@@ -161,6 +161,7 @@ Json deletion_inspection_json(const axk::app::ImageObjectDeletionInspection &ins
                            {"volumeName", impact.volume_name},
                            {"role", impact.role},
                            {"status", impact.status},
+                           {"requested", impact.requested},
                            {"selected", impact.selected},
                            {"storedSizeBytes", impact.stored_size_bytes},
                            {"freedClusters", impact.freed_clusters},
@@ -191,6 +192,8 @@ Json deletion_inspection_json(const axk::app::ImageObjectDeletionInspection &ins
             {"imageId", inspection.image_id},
             {"revision", inspection.revision},
             {"targetObjectIds", inspection.target_object_ids},
+            {"referrerObjectIds", inspection.referrer_object_ids},
+            {"cleanupObjectIds", inspection.cleanup_object_ids},
             {"selectedObjectIds", inspection.selected_object_ids},
             {"impacts", std::move(impacts)},
             {"references", std::move(references)},
diff --git a/apps/application/tests/image_sessions_test.cpp b/apps/application/tests/image_sessions_test.cpp
index 2cb73b7e..cafb3cb9 100644
--- a/apps/application/tests/image_sessions_test.cpp
+++ b/apps/application/tests/image_sessions_test.cpp
@@ -226,6 +226,14 @@ TEST_F(ImageSessionTest, OpensMetadataOnlySessionAndNeverExposesEngineKeysOrPath
     ASSERT_FALSE(sfs->partitions().empty());
     EXPECT_EQ(content->items.front().name, sfs->partitions().front().name);
     EXPECT_NE(content->items.front().display_name, content->items.front().name);
+    ASSERT_TRUE(sfs->partitions().front().allocation.free_space);
+    ASSERT_TRUE(content->items.front().partition_capacity);
+    EXPECT_EQ(content->items.front().partition_capacity->allocated_clusters,
+              sfs->partitions().front().allocation.free_space->allocated_cluster_count);
+    EXPECT_EQ(content->items.front().partition_capacity->free_clusters,
+              sfs->partitions().front().allocation.free_space->free_cluster_count);
+    EXPECT_EQ(content->items.front().partition_capacity->cluster_size_bytes,
+              sfs->partitions().front().allocation.free_space->cluster_size_bytes);
     for (const auto &item : content->items) {
         EXPECT_TRUE(item.id.starts_with("content-"));
         if (item.object_id) {
@@ -665,11 +673,13 @@ TEST_F(ImageSessionTest, PlansOpaqueIdDeletionWithOptionalWaveDataCleanup) {
     const auto sample = std::ranges::find(samples->items, "sine wave", &axk::app::ImageObjectItem::name);
     ASSERT_NE(sample, samples->items.end());
 
-    const auto inspected = sessions.plan_deletion(opened->image_id, "owner-a", opened->revision, {sample->id}, {});
+    const auto inspected = sessions.plan_deletion(opened->image_id, "owner-a", opened->revision, {sample->id}, {}, {});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->inspection.can_apply);
     EXPECT_EQ(inspected->inspection.target_object_ids, std::vector<std::string>{sample->id});
+    EXPECT_TRUE(inspected->inspection.referrer_object_ids.empty());
+    EXPECT_TRUE(inspected->inspection.cleanup_object_ids.empty());
     ASSERT_EQ(inspected->manifest.operations.size(), 1U);
     EXPECT_TRUE(std::holds_alternative<axk::DeleteSampleOperation>(inspected->manifest.operations.front().data));
     const auto optional_wave = std::ranges::find(inspected->inspection.impacts, std::string{"SMPL"},
@@ -678,13 +688,13 @@ TEST_F(ImageSessionTest, PlansOpaqueIdDeletionWithOptionalWaveDataCleanup) {
     EXPECT_EQ(optional_wave->status, "OPTIONAL");
     EXPECT_FALSE(optional_wave->selected);
 
-    const auto selected =
-        sessions.plan_deletion(opened->image_id, "owner-a", opened->revision, {sample->id}, {optional_wave->object_id});
+    const auto selected = sessions.plan_deletion(opened->image_id, "owner-a", opened->revision, {sample->id}, {},
+                                                 {optional_wave->object_id});
     ASSERT_TRUE(selected) << selected.error().message;
     ASSERT_EQ(selected->manifest.operations.size(), 2U);
     EXPECT_GT(selected->inspection.estimated_freed_bytes, 0U);
 
-    const auto stale = sessions.plan_deletion(opened->image_id, "owner-a", opened->revision + 1U, {sample->id}, {});
+    const auto stale = sessions.plan_deletion(opened->image_id, "owner-a", opened->revision + 1U, {sample->id}, {}, {});
     ASSERT_FALSE(stale);
     EXPECT_EQ(stale.error().code, "image_revision_stale");
 }
@@ -698,7 +708,7 @@ TEST_F(ImageSessionTest, DiscoversOnlyConfirmedUnreferencedWaveDataWithinTheRequ
     const auto sample = std::ranges::find(samples->items, "sine wave", &axk::app::ImageObjectItem::name);
     ASSERT_NE(sample, samples->items.end());
     const auto deletion =
-        source_sessions.plan_deletion(source->image_id, "owner-a", source->revision, {sample->id}, {});
+        source_sessions.plan_deletion(source->image_id, "owner-a", source->revision, {sample->id}, {}, {});
     ASSERT_TRUE(deletion) << deletion.error().message;
     ASSERT_TRUE(deletion->inspection.can_apply);
     ASSERT_TRUE(source_sessions.close(source->image_id, "owner-a"));
@@ -938,6 +948,31 @@ TEST_F(ImageSessionTest, ExcludesProgramReferencesFromContainingContentScopes) {
     ASSERT_TRUE(reference_scope) << reference_scope.error().message;
     ASSERT_EQ(reference_scope->items.size(), 1U);
     EXPECT_NE(reference_scope->items.front().type, "PROG");
+
+    const auto volume_objects =
+        sessions.objects(opened->image_id, "owner-a", 100U, std::nullopt, std::nullopt, volume->id);
+    ASSERT_TRUE(volume_objects) << volume_objects.error().message;
+    std::uint64_t stored_volume_size{};
+    for (const auto &object : volume_objects->items)
+        stored_volume_size += object.stored_size_bytes;
+    ASSERT_TRUE(volume->size_bytes);
+    EXPECT_EQ(*volume->size_bytes, stored_volume_size);
+
+    const auto dependency_size = [&](std::string_view type, std::string_view name) -> std::uint64_t {
+        const auto object = std::ranges::find_if(volume_objects->items, [&](const auto &candidate) {
+            return candidate.type == type && candidate.name == name;
+        });
+        EXPECT_NE(object, volume_objects->items.end());
+        if (object == volume_objects->items.end())
+            return 0U;
+        EXPECT_TRUE(object->size_with_dependencies_bytes);
+        return object->size_with_dependencies_bytes.value_or(0U);
+    };
+    EXPECT_EQ(program_scope->items.front().size_with_dependencies_bytes, volume->size_bytes);
+    EXPECT_GT(dependency_size("SBAC", "Bank"), dependency_size("SBNK", "Sample"));
+    EXPECT_GT(dependency_size("SBNK", "Sample"),
+              std::ranges::find(volume_objects->items, "Sample", &axk::app::ImageObjectItem::name)->stored_size_bytes);
+    EXPECT_GT(dependency_size("SBNK", "Direct Sample"), 0U);
 }
 
 TEST_F(ImageSessionTest, PlansProgramsForDisjointUnreferencedSampleBanksAndSamples) {
diff --git a/apps/application/tests/write_operations_test.cpp b/apps/application/tests/write_operations_test.cpp
index 68d0e92b..c3333d77 100644
--- a/apps/application/tests/write_operations_test.cpp
+++ b/apps/application/tests/write_operations_test.cpp
@@ -891,6 +891,64 @@ TEST_F(WriteOperationsTest, SessionAlterationCommitsInPlaceAndRefreshesTheExisti
     EXPECT_EQ(stale.error().code, "image_revision_stale");
 }
 
+TEST_F(WriteOperationsTest, SessionVolumeDeletionInspectionAcceptsMultipleVolumeTargets) {
+    write_tone(root_ / "batch-delete.wav");
+    ASSERT_TRUE(
+        axk::write_hds_image(all_action_source_manifest(root_ / "batch-delete.wav"), root_ / "batch-delete.hds"));
+    const auto opened = images_->open({"workspace", "batch-delete.hds"}, "owner");
+    ASSERT_TRUE(opened) << opened.error().message;
+    const nlohmann::json request = {
+        {"imageId", opened->image_id},
+        {"expectedRevision", opened->revision},
+        {"targets", nlohmann::json::array({{{"partitionIndex", 0U}, {"volumeName", "Volume"}},
+                                           {{"partitionIndex", 0U}, {"volumeName", "Delete Volume"}}})}};
+
+    const auto inspected = registry_.invoke("images.volume_deletion.inspect", request, context());
+
+    ASSERT_TRUE(inspected) << inspected.error().message;
+    EXPECT_EQ(inspected->at("targets"), request.at("targets"));
+    EXPECT_TRUE(inspected->at("canDelete").get<bool>());
+    EXPECT_EQ(inspected->at("crossingRelationshipCount"), 0U);
+    EXPECT_TRUE(inspected->at("blockers").empty());
+}
+
+TEST_F(WriteOperationsTest, SessionAlterationDeletesMultipleVolumesAtomically) {
+    axk::VolumeSpec first;
+    first.name = "First";
+    axk::VolumeSpec second;
+    second.name = "Second";
+    axk::VolumeSpec survivor;
+    survivor.name = "Survivor";
+    const axk::HdsBuildManifest build{
+        "1.0", 4U * 1024U * 1024U, {{"hd1", {std::move(first), std::move(second), std::move(survivor)}}}};
+    ASSERT_TRUE(axk::write_hds_image(build, root_ / "batch-delete-session.hds"));
+    const auto opened = images_->open({"workspace", "batch-delete-session.hds"}, "owner");
+    ASSERT_TRUE(opened) << opened.error().message;
+    const nlohmann::json manifest = {
+        {"schema_version", "1.0"},
+        {"operations",
+         nlohmann::json::array(
+             {{{"id", "first"}, {"type", "delete_volume"}, {"partition_index", 0U}, {"volume_name", "First"}},
+              {{"id", "second"}, {"type", "delete_volume"}, {"partition_index", 0U}, {"volume_name", "Second"}}})},
+    };
+
+    const auto altered = registry_.invoke(
+        "images.alter",
+        {{"imageId", opened->image_id}, {"expectedRevision", opened->revision}, {"manifest", {{"inline", manifest}}}},
+        context());
+
+    ASSERT_TRUE(altered) << altered.error().message;
+    EXPECT_EQ(altered->at("revision"), 2U);
+    const auto roots = images_->content(opened->image_id, "owner", 100U);
+    ASSERT_TRUE(roots) << roots.error().message;
+    ASSERT_EQ(roots->items.size(), 1U);
+    const auto volumes = images_->content(opened->image_id, "owner", 100U, std::nullopt, roots->items.front().id);
+    ASSERT_TRUE(volumes) << volumes.error().message;
+    EXPECT_TRUE(std::ranges::contains(volumes->items, "Survivor", &axk::app::ImageContentItem::name));
+    EXPECT_FALSE(std::ranges::contains(volumes->items, "First", &axk::app::ImageContentItem::name));
+    EXPECT_FALSE(std::ranges::contains(volumes->items, "Second", &axk::app::ImageContentItem::name));
+}
+
 TEST_F(WriteOperationsTest, SessionVolumePlacementRepairMakesDeletionSafe) {
     write_tone(root_ / "repair.wav");
     const auto source = root_ / "placement-repair.hds";
@@ -923,10 +981,10 @@ TEST_F(WriteOperationsTest, SessionVolumePlacementRepairMakesDeletionSafe) {
 
     const auto opened = images_->open({"workspace", "placement-repair.hds"}, "owner");
     ASSERT_TRUE(opened) << opened.error().message;
-    const nlohmann::json request = {{"imageId", opened->image_id},
-                                    {"expectedRevision", opened->revision},
-                                    {"partitionIndex", 0U},
-                                    {"volumeName", "Samples"}};
+    const nlohmann::json request = {
+        {"imageId", opened->image_id},
+        {"expectedRevision", opened->revision},
+        {"targets", nlohmann::json::array({{{"partitionIndex", 0U}, {"volumeName", "Samples"}}})}};
     const auto inspected = registry_.invoke("images.volume_deletion.inspect", request, context());
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_FALSE(inspected->at("canDelete").get<bool>());
@@ -934,11 +992,18 @@ TEST_F(WriteOperationsTest, SessionVolumePlacementRepairMakesDeletionSafe) {
     ASSERT_EQ(inspected->at("blockers").size(), 1U);
 
     auto absent_volume_request = request;
-    absent_volume_request["volumeName"] = "Absent";
+    absent_volume_request["targets"][0]["volumeName"] = "Absent";
     const auto absent_volume = registry_.invoke("images.volume_deletion.inspect", absent_volume_request, context());
     ASSERT_FALSE(absent_volume);
     EXPECT_EQ(absent_volume.error().code, "volume_scope_invalid");
 
+    auto duplicate_targets_request = request;
+    duplicate_targets_request["targets"].push_back(duplicate_targets_request["targets"].front());
+    const auto duplicate_targets =
+        registry_.invoke("images.volume_deletion.inspect", duplicate_targets_request, context());
+    ASSERT_FALSE(duplicate_targets);
+    EXPECT_EQ(duplicate_targets.error().code, "invalid_request");
+
     const nlohmann::json placement_request = {
         {"imageId", opened->image_id},
         {"expectedRevision", opened->revision},
@@ -1070,6 +1135,7 @@ TEST_F(WriteOperationsTest, SessionObjectDeletionInspectsAndCommitsTheReviewedCl
                                              {{"imageId", opened->image_id},
                                               {"expectedRevision", opened->revision},
                                               {"targetObjectIds", nlohmann::json::array({sample->id})},
+                                              {"referrerObjectIds", nlohmann::json::array()},
                                               {"cleanupObjectIds", nlohmann::json::array()}},
                                              context());
     ASSERT_TRUE(inspection) << inspection.error().message;
@@ -1091,6 +1157,7 @@ TEST_F(WriteOperationsTest, SessionObjectDeletionInspectsAndCommitsTheReviewedCl
                                                {{"imageId", opened->image_id},
                                                 {"expectedRevision", opened->revision},
                                                 {"targetObjectIds", nlohmann::json::array({sample->id})},
+                                                {"referrerObjectIds", nlohmann::json::array()},
                                                 {"cleanupObjectIds", included}},
                                                context());
     ASSERT_TRUE(deleted) << deleted.error().message;
diff --git a/apps/axkdeck/README.md b/apps/axkdeck/README.md
index 80f1abe5..b3d23014 100644
--- a/apps/axkdeck/README.md
+++ b/apps/axkdeck/README.md
@@ -55,6 +55,10 @@ build directory.
 The same Git tag versions axklib and axkdeck. `desktop:dev` and
 `desktop:build` read `version_metadata.json` and `package_basename.txt` from the
 native build, inject that identity into Tauri, and embed it in the Rust binary.
+Recognized bare, `release/`, `feature/`, `features/`, `bugfix/`, and `bugfixes/`
+version branches accept `0.3.6` or `v0.3.6`, use semantic version `0.3.6-pre`,
+and use source identity `0.3.6-pre-<short-sha>` or
+`0.3.6-pre-dirty-<short-sha>`.
 The tracked npm and Cargo versions are `0.0.0` placeholders and are not release
 version sources. A locally launched desktop refuses a bundled sidecar whose
 semantic version or source identity differs, so rebuild the native server after
@@ -341,6 +345,45 @@ and the normal deletion inspection immediately before starting the job; a
 changed or newly referenced candidate returns to review instead of being
 deleted. Discovery is capped at 1,024 candidates per pass.
 
+### Settings
+
+Axkdeck stores its per-user settings under one vendor-scoped configuration
+directory:
+
+- `%APPDATA%\tphzz\axkdeck` on Windows;
+- `$XDG_CONFIG_HOME/tphzz/axkdeck` on Linux, or
+  `~/.config/tphzz/axkdeck` when `XDG_CONFIG_HOME` is unset; and
+- `~/Library/Application Support/tphzz/axkdeck` on macOS.
+
+`settings.json` is the single versioned axkdeck settings document. It groups UI
+appearance settings, including interface scale, separately from last-used
+directories so future settings remain organized. The local sidecar's configured
+storage roots remain operational server data and are stored separately at
+`axklib-server/workspaces.json` below the same axkdeck directory. Axkdeck passes
+that path explicitly when it starts the sidecar.
+
+```json
+{
+  "schemaVersion": 1,
+  "appearance": {
+    "interfaceScaleMode": "auto"
+  },
+  "lastUsedDirectories": {
+    "packageExport": null,
+    "directoryExport": null,
+    "mediaExport": null,
+    "allocationExport": null
+  }
+}
+```
+
+An independently launched `axklib-server` does not share the sidecar registry.
+It uses its own `tphzz/axklib-server/workspaces.json` configuration path unless
+`--workspace-store` or `workspaceStore` explicitly selects another file. The
+earlier unreleased filenames and locations are not read or migrated. Logs,
+WebView profile/cache data, protected credentials, and sidecar operational
+state remain in their platform-specific application locations.
+
 ### Diagnostics
 
 Development builds open the web developer tools with `F12`. This shortcut is
diff --git a/apps/axkdeck/src-tauri/build_support.rs b/apps/axkdeck/src-tauri/build_support.rs
index 359cca0b..68cece2c 100644
--- a/apps/axkdeck/src-tauri/build_support.rs
+++ b/apps/axkdeck/src-tauri/build_support.rs
@@ -73,14 +73,22 @@ pub fn read_build_identity(
         return Err("native project version does not match its numeric components".to_owned());
     }
     if metadata.is_release {
-        if metadata.release_tag != format!("v{}", metadata.semantic_version) {
+        if metadata
+            .release_tag
+            .strip_prefix('v')
+            .unwrap_or(&metadata.release_tag)
+            != metadata.semantic_version
+        {
             return Err("native release tag does not match its semantic version".to_owned());
         }
-    } else if metadata.semantic_version != "0.0.0"
-        || !metadata.release_tag.is_empty()
-        || metadata.is_prerelease
-    {
-        return Err("native development version metadata is inconsistent".to_owned());
+    } else {
+        let fallback_development = metadata.semantic_version == "0.0.0" && !metadata.is_prerelease;
+        let version_branch = metadata.semantic_version
+            == format!("{}-pre", metadata.project_version)
+            && metadata.is_prerelease;
+        if !metadata.release_tag.is_empty() || (!fallback_development && !version_branch) {
+            return Err("native development version metadata is inconsistent".to_owned());
+        }
     }
 
     let package_text = std::fs::read_to_string(package_basename_path).map_err(|error| {
diff --git a/apps/axkdeck/src-tauri/resources/axkdeck.spdx.json b/apps/axkdeck/src-tauri/resources/axkdeck.spdx.json
index b9c30db2..7cc071b8 100644
--- a/apps/axkdeck/src-tauri/resources/axkdeck.spdx.json
+++ b/apps/axkdeck/src-tauri/resources/axkdeck.spdx.json
@@ -3,7 +3,7 @@
   "dataLicense": "CC0-1.0",
   "SPDXID": "SPDXRef-DOCUMENT",
   "name": "axkdeck-release",
-  "comment": "axklib source identity: feature-axkserver-finetuning-00ca159-mod",
+  "comment": "axklib source identity: feature-axkserver-finetuning-dirty-00ca159",
   "documentNamespace": "https://github.com/tphzz/axklib/spdx/b3d5ae714dfe90ddc5b0c0a1e171be8a8ab8fb9a9400cce5b91c6f2c0cf14102",
   "creationInfo": {
     "creators": [
@@ -21,7 +21,7 @@
       "filesAnalyzed": false,
       "licenseConcluded": "NOASSERTION",
       "licenseDeclared": "MIT OR Apache-2.0",
-      "comment": "monorepo source identity: feature-axkserver-finetuning-00ca159-mod"
+      "comment": "monorepo source identity: feature-axkserver-finetuning-dirty-00ca159"
     },
     {
       "SPDXID": "SPDXRef-axklib-axklib-0.0.0",
diff --git a/apps/axkdeck/src-tauri/src/allocation_inspector.rs b/apps/axkdeck/src-tauri/src/allocation_inspector.rs
index b1e26d87..918803b1 100644
--- a/apps/axkdeck/src-tauri/src/allocation_inspector.rs
+++ b/apps/axkdeck/src-tauri/src/allocation_inspector.rs
@@ -148,7 +148,7 @@ pub(crate) async fn save_allocation_map_json(
     let starting_directory = match preferences.lock() {
         Ok(preferences) => preferences.allocation_export_directory(),
         Err(_) => {
-            log::warn!("desktop preference state is unavailable; using the platform save location");
+            log::warn!("axkdeck settings state is unavailable; using the platform save location");
             None
         }
     };
@@ -186,7 +186,7 @@ pub(crate) async fn save_allocation_map_json(
         }
         Err(_) => {
             log::warn!(
-                "desktop preference state is unavailable; the allocation export directory was not retained"
+                "axkdeck settings state is unavailable; the allocation export directory was not retained"
             );
         }
     }
diff --git a/apps/axkdeck/src-tauri/src/desktop_preferences.rs b/apps/axkdeck/src-tauri/src/desktop_preferences.rs
index 775b5c9d..24e194f3 100644
--- a/apps/axkdeck/src-tauri/src/desktop_preferences.rs
+++ b/apps/axkdeck/src-tauri/src/desktop_preferences.rs
@@ -5,13 +5,54 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
 
+const SETTINGS_SCHEMA_VERSION: u32 = 1;
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+pub enum InterfaceScaleMode {
+    #[default]
+    #[serde(rename = "auto")]
+    Auto,
+    #[serde(rename = "1")]
+    One,
+    #[serde(rename = "1.15")]
+    OnePointFifteen,
+    #[serde(rename = "1.25")]
+    OnePointTwentyFive,
+    #[serde(rename = "1.5")]
+    OnePointFive,
+}
+
 #[derive(Default, Deserialize, Serialize)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct AppearanceSettings {
+    interface_scale_mode: InterfaceScaleMode,
+}
+
+#[derive(Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct LastUsedDirectories {
+    package_export: Option<PathBuf>,
+    directory_export: Option<PathBuf>,
+    media_export: Option<PathBuf>,
+    allocation_export: Option<PathBuf>,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
 struct DesktopPreferences {
-    last_package_export_directory: Option<PathBuf>,
-    last_directory_export_directory: Option<PathBuf>,
-    last_media_export_directory: Option<PathBuf>,
-    last_allocation_export_directory: Option<PathBuf>,
+    schema_version: u32,
+    appearance: AppearanceSettings,
+    last_used_directories: LastUsedDirectories,
+}
+
+impl Default for DesktopPreferences {
+    fn default() -> Self {
+        Self {
+            schema_version: SETTINGS_SCHEMA_VERSION,
+            appearance: AppearanceSettings::default(),
+            last_used_directories: LastUsedDirectories::default(),
+        }
+    }
 }
 
 pub struct DesktopPreferencesStore {
@@ -21,14 +62,20 @@ pub struct DesktopPreferencesStore {
 
 impl DesktopPreferencesStore {
     pub fn load(document_path: PathBuf) -> Result<Self, String> {
-        let preferences = match std::fs::read(&document_path) {
+        let preferences: DesktopPreferences = match std::fs::read(&document_path) {
             Ok(bytes) => serde_json::from_slice(&bytes)
-                .map_err(|error| format!("parse desktop preferences: {error}"))?,
+                .map_err(|error| format!("parse axkdeck settings: {error}"))?,
             Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
                 DesktopPreferences::default()
             }
-            Err(error) => return Err(format!("read desktop preferences: {error}")),
+            Err(error) => return Err(format!("read axkdeck settings: {error}")),
         };
+        if preferences.schema_version != SETTINGS_SCHEMA_VERSION {
+            return Err(format!(
+                "unsupported axkdeck settings schema version: {}",
+                preferences.schema_version
+            ));
+        }
         Ok(Self {
             document_path,
             preferences,
@@ -42,9 +89,19 @@ impl DesktopPreferencesStore {
         }
     }
 
+    pub fn interface_scale_mode(&self) -> InterfaceScaleMode {
+        self.preferences.appearance.interface_scale_mode
+    }
+
+    pub fn set_interface_scale_mode(&mut self, mode: InterfaceScaleMode) -> Result<(), String> {
+        self.preferences.appearance.interface_scale_mode = mode;
+        self.persist()
+    }
+
     pub fn package_export_directory(&self) -> Option<PathBuf> {
         self.preferences
-            .last_package_export_directory
+            .last_used_directories
+            .package_export
             .as_ref()
             .filter(|directory| directory.is_dir())
             .cloned()
@@ -57,13 +114,14 @@ impl DesktopPreferencesStore {
         if !directory.is_dir() {
             return Err("the package export location is not a directory".to_owned());
         }
-        self.preferences.last_package_export_directory = Some(directory);
+        self.preferences.last_used_directories.package_export = Some(directory);
         self.persist()
     }
 
     pub fn directory_export_directory(&self) -> Option<PathBuf> {
         self.preferences
-            .last_directory_export_directory
+            .last_used_directories
+            .directory_export
             .as_ref()
             .filter(|directory| directory.is_dir())
             .cloned()
@@ -76,13 +134,14 @@ impl DesktopPreferencesStore {
         if !directory.is_dir() {
             return Err("the directory export location is not a directory".to_owned());
         }
-        self.preferences.last_directory_export_directory = Some(directory);
+        self.preferences.last_used_directories.directory_export = Some(directory);
         self.persist()
     }
 
     pub fn media_export_directory(&self) -> Option<PathBuf> {
         self.preferences
-            .last_media_export_directory
+            .last_used_directories
+            .media_export
             .as_ref()
             .filter(|directory| directory.is_dir())
             .cloned()
@@ -95,13 +154,14 @@ impl DesktopPreferencesStore {
         if !directory.is_dir() {
             return Err("the media export location is not a directory".to_owned());
         }
-        self.preferences.last_media_export_directory = Some(directory);
+        self.preferences.last_used_directories.media_export = Some(directory);
         self.persist()
     }
 
     pub fn allocation_export_directory(&self) -> Option<PathBuf> {
         self.preferences
-            .last_allocation_export_directory
+            .last_used_directories
+            .allocation_export
             .as_ref()
             .filter(|directory| directory.is_dir())
             .cloned()
@@ -114,13 +174,13 @@ impl DesktopPreferencesStore {
         if !directory.is_dir() {
             return Err("the allocation export location is not a directory".to_owned());
         }
-        self.preferences.last_allocation_export_directory = Some(directory);
+        self.preferences.last_used_directories.allocation_export = Some(directory);
         self.persist()
     }
 
     fn persist(&self) -> Result<(), String> {
         let mut encoded = serde_json::to_vec_pretty(&self.preferences)
-            .map_err(|error| format!("encode desktop preferences: {error}"))?;
+            .map_err(|error| format!("encode axkdeck settings: {error}"))?;
         encoded.push(b'\n');
         write_atomically(&self.document_path, &encoded)
     }
@@ -130,11 +190,11 @@ fn temporary_sibling(destination: &Path) -> Result<(PathBuf, File), String> {
     let parent = destination
         .parent()
         .filter(|path| !path.as_os_str().is_empty())
-        .ok_or_else(|| "desktop preferences path has no parent directory".to_owned())?;
+        .ok_or_else(|| "axkdeck settings path has no parent directory".to_owned())?;
     let name = destination
         .file_name()
         .and_then(|value| value.to_str())
-        .unwrap_or("desktop-preferences");
+        .unwrap_or("settings");
     for attempt in 0_u8..16 {
         let nonce = SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -147,27 +207,27 @@ fn temporary_sibling(destination: &Path) -> Result<(PathBuf, File), String> {
         match OpenOptions::new().create_new(true).write(true).open(&path) {
             Ok(file) => return Ok((path, file)),
             Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
-            Err(error) => return Err(format!("create desktop preferences staging file: {error}")),
+            Err(error) => return Err(format!("create axkdeck settings staging file: {error}")),
         }
     }
-    Err("could not reserve a desktop preferences staging file".to_owned())
+    Err("could not reserve an axkdeck settings staging file".to_owned())
 }
 
 fn write_atomically(destination: &Path, bytes: &[u8]) -> Result<(), String> {
     let parent = destination
         .parent()
         .filter(|path| !path.as_os_str().is_empty())
-        .ok_or_else(|| "desktop preferences path has no parent directory".to_owned())?;
+        .ok_or_else(|| "axkdeck settings path has no parent directory".to_owned())?;
     std::fs::create_dir_all(parent)
-        .map_err(|error| format!("create desktop preferences directory: {error}"))?;
+        .map_err(|error| format!("create axkdeck settings directory: {error}"))?;
     let (temporary, mut output) = temporary_sibling(destination)?;
     let result = (|| {
         output
             .write_all(bytes)
-            .map_err(|error| format!("write desktop preferences: {error}"))?;
+            .map_err(|error| format!("write axkdeck settings: {error}"))?;
         output
             .sync_all()
-            .map_err(|error| format!("flush desktop preferences: {error}"))?;
+            .map_err(|error| format!("flush axkdeck settings: {error}"))?;
         drop(output);
         let outcome = crate::file_publication::publish_file(&temporary, destination)?;
         if let Some(warning) = outcome.warning {
@@ -187,7 +247,7 @@ mod tests {
     use std::path::PathBuf;
     use std::time::{SystemTime, UNIX_EPOCH};
 
-    use super::DesktopPreferencesStore;
+    use super::{DesktopPreferencesStore, InterfaceScaleMode};
 
     fn temporary_directory(name: &str) -> PathBuf {
         let nonce = SystemTime::now()
@@ -207,7 +267,7 @@ mod tests {
         let root = temporary_directory("reload");
         let export_directory = root.join("exports");
         fs::create_dir(&export_directory).expect("create export directory");
-        let document = root.join("desktop-preferences.json");
+        let document = root.join("settings.json");
 
         let mut store =
             DesktopPreferencesStore::load(document.clone()).expect("load empty preferences");
@@ -227,6 +287,93 @@ mod tests {
         fs::remove_dir_all(root).expect("remove temporary directory");
     }
 
+    #[test]
+    fn interface_scale_mode_defaults_to_auto_and_survives_reload() {
+        let root = temporary_directory("interface-scale");
+        let document = root.join("settings.json");
+        let mut store =
+            DesktopPreferencesStore::load(document.clone()).expect("load empty preferences");
+
+        assert_eq!(store.interface_scale_mode(), InterfaceScaleMode::Auto);
+        store
+            .set_interface_scale_mode(InterfaceScaleMode::OnePointFifteen)
+            .expect("persist interface scale");
+
+        let reloaded = DesktopPreferencesStore::load(document).expect("reload preferences");
+        assert_eq!(
+            reloaded.interface_scale_mode(),
+            InterfaceScaleMode::OnePointFifteen
+        );
+        let persisted: serde_json::Value = serde_json::from_slice(
+            &fs::read(root.join("settings.json")).expect("read persisted settings"),
+        )
+        .expect("parse persisted settings");
+        assert_eq!(persisted["schemaVersion"], 1);
+        assert_eq!(persisted["appearance"]["interfaceScaleMode"], "1.15");
+        assert!(persisted["lastUsedDirectories"]["packageExport"].is_null());
+        assert!(persisted["lastUsedDirectories"]["directoryExport"].is_null());
+        assert!(persisted["lastUsedDirectories"]["mediaExport"].is_null());
+        assert!(persisted["lastUsedDirectories"]["allocationExport"].is_null());
+        fs::remove_dir_all(root).expect("remove temporary directory");
+    }
+
+    #[test]
+    fn obsolete_unreleased_preferences_file_is_not_read() {
+        let root = temporary_directory("obsolete-preferences");
+        fs::write(
+            root.join("desktop-preferences.json"),
+            br#"{"interfaceScaleMode":"1.5"}"#,
+        )
+        .expect("write obsolete preferences");
+
+        let store = DesktopPreferencesStore::load(root.join("settings.json"))
+            .expect("load current settings");
+        assert_eq!(store.interface_scale_mode(), InterfaceScaleMode::Auto);
+        fs::remove_dir_all(root).expect("remove temporary directory");
+    }
+
+    #[test]
+    fn unsupported_interface_scale_modes_are_rejected() {
+        let root = temporary_directory("invalid-interface-scale");
+        let document = root.join("settings.json");
+        fs::write(
+            &document,
+            br#"{"schemaVersion":1,"appearance":{"interfaceScaleMode":"2"},"lastUsedDirectories":{}}"#,
+        )
+        .expect("write invalid preferences");
+
+        assert!(DesktopPreferencesStore::load(document).is_err());
+        fs::remove_dir_all(root).expect("remove temporary directory");
+    }
+
+    #[test]
+    fn unsupported_settings_schema_versions_are_rejected() {
+        let root = temporary_directory("unsupported-schema");
+        let document = root.join("settings.json");
+        fs::write(
+            &document,
+            br#"{"schemaVersion":2,"appearance":{"interfaceScaleMode":"auto"},"lastUsedDirectories":{}}"#,
+        )
+        .expect("write unsupported settings");
+
+        assert!(DesktopPreferencesStore::load(document).is_err());
+        fs::remove_dir_all(root).expect("remove temporary directory");
+    }
+
+    #[test]
+    fn unknown_settings_fields_are_rejected() {
+        let root = temporary_directory("unknown-field");
+        let document = root.join("settings.json");
+        fs::write(
+            &document,
+            br#"{"schemaVersion":1,"appearance":{"interfaceScaleMode":"auto"},"lastUsedDirectories":{},"legacy":true}"#,
+        )
+        .expect("write settings with unknown field");
+
+        assert!(DesktopPreferencesStore::load(document).is_err());
+        fs::remove_dir_all(root).expect("remove temporary directory");
+    }
+
     #[test]
     fn directory_export_location_is_remembered_separately() {
         let root = temporary_directory("directory-reload");
@@ -234,7 +381,7 @@ mod tests {
         let directory_export = root.join("directory-exports");
         fs::create_dir(&package_directory).expect("create package directory");
         fs::create_dir(&directory_export).expect("create directory export location");
-        let document = root.join("desktop-preferences.json");
+        let document = root.join("settings.json");
 
         let mut store =
             DesktopPreferencesStore::load(document.clone()).expect("load empty preferences");
@@ -272,7 +419,7 @@ mod tests {
         let allocation_export = root.join("allocation-exports");
         fs::create_dir(&package_directory).expect("create package directory");
         fs::create_dir(&allocation_export).expect("create allocation export location");
-        let document = root.join("desktop-preferences.json");
+        let document = root.join("settings.json");
 
         let mut store =
             DesktopPreferencesStore::load(document.clone()).expect("load empty preferences");
@@ -302,7 +449,7 @@ mod tests {
         let second_directory = root.join("second");
         fs::create_dir(&first_directory).expect("create first export directory");
         fs::create_dir(&second_directory).expect("create second export directory");
-        let document = root.join("desktop-preferences.json");
+        let document = root.join("settings.json");
 
         let mut store =
             DesktopPreferencesStore::load(document.clone()).expect("load empty preferences");
@@ -330,7 +477,7 @@ mod tests {
         let root = temporary_directory("missing");
         let export_directory = root.join("exports");
         fs::create_dir(&export_directory).expect("create export directory");
-        let document = root.join("desktop-preferences.json");
+        let document = root.join("settings.json");
 
         let mut store =
             DesktopPreferencesStore::load(document.clone()).expect("load empty preferences");
@@ -349,7 +496,7 @@ mod tests {
         let root = temporary_directory("not-directory");
         let export_directory = root.join("exports");
         fs::create_dir(&export_directory).expect("create export directory");
-        let document = root.join("desktop-preferences.json");
+        let document = root.join("settings.json");
 
         let mut store =
             DesktopPreferencesStore::load(document.clone()).expect("load empty preferences");
@@ -367,7 +514,7 @@ mod tests {
     #[test]
     fn malformed_preferences_are_rejected_for_startup_to_reset() {
         let root = temporary_directory("malformed");
-        let document = root.join("desktop-preferences.json");
+        let document = root.join("settings.json");
         fs::write(&document, b"{not-json").expect("write malformed preferences");
 
         assert!(DesktopPreferencesStore::load(document).is_err());
diff --git a/apps/axkdeck/src-tauri/src/lib.rs b/apps/axkdeck/src-tauri/src/lib.rs
index f4c330ef..44891e82 100644
--- a/apps/axkdeck/src-tauri/src/lib.rs
+++ b/apps/axkdeck/src-tauri/src/lib.rs
@@ -7,6 +7,7 @@ mod local_workspaces;
 mod remote_settings;
 mod retained_download;
 mod server_sidecar;
+mod settings_paths;
 mod startup_diagnostics;
 mod webview_runtime;
 
@@ -18,7 +19,7 @@ use tauri::{Manager, State, WebviewWindow};
 use tauri_plugin_log::{RotationStrategy, Target, TargetKind};
 
 use allocation_inspector::{open_allocation_inspector, save_allocation_map_json};
-use desktop_preferences::DesktopPreferencesStore;
+use desktop_preferences::{DesktopPreferencesStore, InterfaceScaleMode};
 use local_directory_exports::{
     DirectorySaveCandidateStore, save_retained_directory_export,
     select_local_directory_export_destination,
@@ -29,6 +30,7 @@ use local_packages::{
     select_local_packages,
 };
 use local_workspaces::{WorkspaceCandidateStore, commit_local_workspace, select_local_workspace};
+use settings_paths::SettingsPaths;
 use startup_diagnostics::{StartupDiagnostics, StartupMilestone, complete_startup};
 
 const LOG_FILE_SIZE: u128 = 5 * 1024 * 1024;
@@ -60,6 +62,27 @@ fn current_build_info() -> DesktopBuildInfo {
     }
 }
 
+#[tauri::command]
+fn desktop_interface_scale_mode(
+    preferences: State<'_, Mutex<DesktopPreferencesStore>>,
+) -> InterfaceScaleMode {
+    preferences
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+        .interface_scale_mode()
+}
+
+#[tauri::command]
+fn set_desktop_interface_scale_mode(
+    mode: InterfaceScaleMode,
+    preferences: State<'_, Mutex<DesktopPreferencesStore>>,
+) -> Result<(), String> {
+    preferences
+        .lock()
+        .map_err(|_| "axkdeck settings state is unavailable".to_owned())?
+        .set_interface_scale_mode(mode)
+}
+
 fn parse_log_level(value: Option<&str>) -> log::LevelFilter {
     match value.map(str::trim).map(str::to_ascii_lowercase).as_deref() {
         Some("trace") => log::LevelFilter::Trace,
@@ -441,12 +464,17 @@ pub fn run() {
                 .path()
                 .app_local_data_dir()
                 .map_err(|error| format!("resolve application state directory: {error}"))?;
+            let config_directory = app
+                .path()
+                .config_dir()
+                .map_err(|error| format!("resolve application config directory: {error}"))?;
+            let settings_paths = SettingsPaths::from_config_directory(&config_directory);
             setup_startup.record(StartupMilestone::PathsResolved);
-            let preferences_path = application_data_directory.join("desktop-preferences.json");
+            let settings_path = settings_paths.axkdeck_settings;
             setup_startup.record(StartupMilestone::PreferencesLoadStarted);
-            let preferences = DesktopPreferencesStore::load(preferences_path.clone()).unwrap_or_else(|error| {
-                log::warn!("desktop preferences are unavailable and will be reset on the next update: {error}");
-                DesktopPreferencesStore::empty(preferences_path)
+            let preferences = DesktopPreferencesStore::load(settings_path.clone()).unwrap_or_else(|error| {
+                log::warn!("axkdeck settings are unavailable and will be reset on the next update: {error}");
+                DesktopPreferencesStore::empty(settings_path)
             });
             setup_startup.record(StartupMilestone::PreferencesLoadCompleted);
             app.manage(Mutex::new(preferences));
@@ -455,6 +483,7 @@ pub fn run() {
             connections.initialize_in_background(
                 log_directory,
                 state_directory,
+                settings_paths.sidecar_workspace_store,
                 setup_startup.clone(),
             );
             app.manage(connections);
@@ -500,6 +529,8 @@ pub fn run() {
             open_developer_tools,
             diagnostic_log_level,
             desktop_build_info,
+            desktop_interface_scale_mode,
+            set_desktop_interface_scale_mode,
             open_allocation_inspector,
             save_allocation_map_json
         ]);
diff --git a/apps/axkdeck/src-tauri/src/local_directory_exports.rs b/apps/axkdeck/src-tauri/src/local_directory_exports.rs
index f212af8a..cdc5c88b 100644
--- a/apps/axkdeck/src-tauri/src/local_directory_exports.rs
+++ b/apps/axkdeck/src-tauri/src/local_directory_exports.rs
@@ -78,7 +78,7 @@ pub(crate) async fn select_local_directory_export_destination(
     let starting_directory = match preferences.lock() {
         Ok(preferences) => preferences.directory_export_directory(),
         Err(_) => {
-            log::warn!("desktop preference state is unavailable; using the platform save location");
+            log::warn!("axkdeck settings state is unavailable; using the platform save location");
             None
         }
     };
@@ -118,7 +118,7 @@ pub(crate) async fn select_local_directory_export_destination(
             }
             Err(_) => {
                 log::warn!(
-                    "desktop preference state is unavailable; the directory export location was not retained"
+                    "axkdeck settings state is unavailable; the directory export location was not retained"
                 );
             }
         }
diff --git a/apps/axkdeck/src-tauri/src/local_packages.rs b/apps/axkdeck/src-tauri/src/local_packages.rs
index c0517943..8edbb6a2 100644
--- a/apps/axkdeck/src-tauri/src/local_packages.rs
+++ b/apps/axkdeck/src-tauri/src/local_packages.rs
@@ -230,7 +230,7 @@ pub(crate) async fn select_local_package_destination(
     let starting_directory = match preferences.lock() {
         Ok(preferences) => preferences.package_export_directory(),
         Err(_) => {
-            log::warn!("desktop preference state is unavailable; using the platform save location");
+            log::warn!("axkdeck settings state is unavailable; using the platform save location");
             None
         }
     };
@@ -270,7 +270,7 @@ pub(crate) async fn select_local_package_destination(
             }
             Err(_) => {
                 log::warn!(
-                    "desktop preference state is unavailable; the package export directory was not retained"
+                    "axkdeck settings state is unavailable; the package export directory was not retained"
                 );
             }
         }
@@ -306,7 +306,7 @@ pub(crate) async fn select_local_media_destination(
     let starting_directory = match preferences.lock() {
         Ok(preferences) => preferences.media_export_directory(),
         Err(_) => {
-            log::warn!("desktop preference state is unavailable; using the platform save location");
+            log::warn!("axkdeck settings state is unavailable; using the platform save location");
             None
         }
     };
@@ -346,7 +346,7 @@ pub(crate) async fn select_local_media_destination(
             }
             Err(_) => {
                 log::warn!(
-                    "desktop preference state is unavailable; the media export directory was not retained"
+                    "axkdeck settings state is unavailable; the media export directory was not retained"
                 );
             }
         }
diff --git a/apps/axkdeck/src-tauri/src/remote_settings.rs b/apps/axkdeck/src-tauri/src/remote_settings.rs
index 0efcf9a0..c9fdd93d 100644
--- a/apps/axkdeck/src-tauri/src/remote_settings.rs
+++ b/apps/axkdeck/src-tauri/src/remote_settings.rs
@@ -42,6 +42,7 @@ pub struct ServerConnectionManager {
     secure_storage_error: Option<String>,
     log_directory: PathBuf,
     state_directory: PathBuf,
+    workspace_store: PathBuf,
 }
 
 struct ServerConnectionStateInner {
@@ -68,11 +69,13 @@ impl ServerConnectionState {
         &self,
         log_directory: PathBuf,
         state_directory: PathBuf,
+        workspace_store: PathBuf,
         startup: StartupDiagnostics,
     ) {
         let worker_state = self.clone();
         let worker_log_directory = log_directory.clone();
         let worker_state_directory = state_directory.clone();
+        let worker_workspace_store = workspace_store.clone();
         let worker = std::thread::Builder::new()
             .name("axkdeck-server-startup".to_owned())
             .spawn(move || {
@@ -80,6 +83,7 @@ impl ServerConnectionState {
                     ServerConnectionManager::initialize(
                         worker_log_directory.clone(),
                         worker_state_directory.clone(),
+                        worker_workspace_store.clone(),
                         &startup,
                     )
                 }))
@@ -91,6 +95,7 @@ impl ServerConnectionState {
                         error,
                         worker_log_directory,
                         worker_state_directory,
+                        worker_workspace_store,
                     )
                 });
                 worker_state.complete(manager);
@@ -102,6 +107,7 @@ impl ServerConnectionState {
                 message,
                 log_directory,
                 state_directory,
+                workspace_store,
             ));
         }
     }
@@ -158,6 +164,7 @@ impl ServerConnectionManager {
     pub fn initialize(
         log_directory: PathBuf,
         state_directory: PathBuf,
+        workspace_store: PathBuf,
         startup: &StartupDiagnostics,
     ) -> Result<Self, String> {
         startup.record(StartupMilestone::CredentialLookupStarted);
@@ -177,24 +184,45 @@ impl ServerConnectionManager {
                     secure_storage_error: None,
                     log_directory,
                     state_directory,
+                    workspace_store,
                 })
             }
-            Ok(None) => Self::local(log_directory, state_directory, None, Some(startup)),
-            Err(error) => Self::local(log_directory, state_directory, Some(error), Some(startup)),
+            Ok(None) => Self::local(
+                log_directory,
+                state_directory,
+                workspace_store,
+                None,
+                Some(startup),
+            ),
+            Err(error) => Self::local(
+                log_directory,
+                state_directory,
+                workspace_store,
+                Some(error),
+                Some(startup),
+            ),
         }
     }
 
     fn local(
         log_directory: PathBuf,
         state_directory: PathBuf,
+        workspace_store: PathBuf,
         secure_storage_error: Option<String>,
         startup: Option<&StartupDiagnostics>,
     ) -> Result<Self, String> {
         let sidecar = match startup {
-            Some(startup) => {
-                ServerSidecar::launch_at_startup(&log_directory, &state_directory, startup)?
-            }
-            None => ServerSidecar::launch_if_available(&log_directory, &state_directory)?,
+            Some(startup) => ServerSidecar::launch_at_startup(
+                &log_directory,
+                &state_directory,
+                &workspace_store,
+                startup,
+            )?,
+            None => ServerSidecar::launch_if_available(
+                &log_directory,
+                &state_directory,
+                &workspace_store,
+            )?,
         };
         let connection = sidecar.as_ref().map(|server| server.connection().clone());
         Ok(Self {
@@ -203,16 +231,23 @@ impl ServerConnectionManager {
             secure_storage_error,
             log_directory,
             state_directory,
+            workspace_store,
         })
     }
 
-    pub fn unavailable(error: String, log_directory: PathBuf, state_directory: PathBuf) -> Self {
+    pub fn unavailable(
+        error: String,
+        log_directory: PathBuf,
+        state_directory: PathBuf,
+        workspace_store: PathBuf,
+    ) -> Self {
         Self {
             sidecar: None,
             connection: None,
             secure_storage_error: Some(error),
             log_directory,
             state_directory,
+            workspace_store,
         }
     }
 
@@ -256,8 +291,11 @@ impl ServerConnectionManager {
     }
 
     pub fn use_local(&mut self) -> Result<RemoteServerSettingsView, String> {
-        let sidecar =
-            ServerSidecar::launch_if_available(&self.log_directory, &self.state_directory)?;
+        let sidecar = ServerSidecar::launch_if_available(
+            &self.log_directory,
+            &self.state_directory,
+            &self.workspace_store,
+        )?;
         let connection = sidecar.as_ref().map(|server| server.connection().clone());
         delete_remote_settings()?;
         self.connection = connection;
@@ -444,6 +482,7 @@ mod tests {
             "sidecar unavailable".to_owned(),
             PathBuf::from("logs"),
             PathBuf::from("state"),
+            PathBuf::from("config/workspaces.json"),
         ));
         let settings = result_receiver
             .recv_timeout(Duration::from_secs(1))
diff --git a/apps/axkdeck/src-tauri/src/server_sidecar.rs b/apps/axkdeck/src-tauri/src/server_sidecar.rs
index e479ebe0..b101160a 100644
--- a/apps/axkdeck/src-tauri/src/server_sidecar.rs
+++ b/apps/axkdeck/src-tauri/src/server_sidecar.rs
@@ -115,21 +115,29 @@ impl ServerSidecar {
     pub fn launch_if_available(
         log_directory: &Path,
         state_directory: &Path,
+        workspace_store: &Path,
     ) -> Result<Option<Self>, String> {
-        Self::launch_if_available_inner(log_directory, state_directory, None)
+        Self::launch_if_available_inner(log_directory, state_directory, workspace_store, None)
     }
 
     pub fn launch_at_startup(
         log_directory: &Path,
         state_directory: &Path,
+        workspace_store: &Path,
         startup: &StartupDiagnostics,
     ) -> Result<Option<Self>, String> {
-        Self::launch_if_available_inner(log_directory, state_directory, Some(startup))
+        Self::launch_if_available_inner(
+            log_directory,
+            state_directory,
+            workspace_store,
+            Some(startup),
+        )
     }
 
     fn launch_if_available_inner(
         log_directory: &Path,
         state_directory: &Path,
+        workspace_store: &Path,
         startup: Option<&StartupDiagnostics>,
     ) -> Result<Option<Self>, String> {
         if let Some(startup) = startup {
@@ -148,7 +156,13 @@ impl ServerSidecar {
             complete_sidecar_startup(startup, ServerOutcome::BinaryUnavailable);
             return Ok(None);
         };
-        match Self::launch(&binary, log_directory, state_directory, startup) {
+        match Self::launch(
+            &binary,
+            log_directory,
+            state_directory,
+            workspace_store,
+            startup,
+        ) {
             Ok(sidecar) => {
                 complete_sidecar_startup(startup, ServerOutcome::LocalReady);
                 Ok(Some(sidecar))
@@ -164,13 +178,14 @@ impl ServerSidecar {
         binary: &Path,
         log_directory: &Path,
         state_directory: &Path,
+        workspace_store: &Path,
         startup: Option<&StartupDiagnostics>,
     ) -> Result<Self, String> {
         prepare_persistent_state_directory(state_directory)?;
         let runtime_directory = PrivateRuntimeDirectory::create(&std::env::temp_dir())?;
         record_startup(startup, StartupMilestone::SidecarStatePrepared);
         let connection_path = runtime_directory.connection_path();
-        let arguments = sidecar_arguments(state_directory, &connection_path);
+        let arguments = sidecar_arguments(state_directory, workspace_store, &connection_path);
         let mut command = Command::new(binary);
         command
             .args(arguments)
@@ -521,12 +536,18 @@ fn request_shutdown(connection: &FrontendConnection) -> Result<(), String> {
     Ok(())
 }
 
-fn sidecar_arguments(state_directory: &Path, connection_path: &Path) -> Vec<OsString> {
+fn sidecar_arguments(
+    state_directory: &Path,
+    workspace_store: &Path,
+    connection_path: &Path,
+) -> Vec<OsString> {
     let mut arguments = vec![
         "--port".into(),
         "0".into(),
         "--state-directory".into(),
         state_directory.as_os_str().into(),
+        "--workspace-store".into(),
+        workspace_store.as_os_str().into(),
         "--connection-file".into(),
         connection_path.as_os_str().into(),
         "--parent-pid".into(),
diff --git a/apps/axkdeck/src-tauri/src/server_sidecar_tests.rs b/apps/axkdeck/src-tauri/src/server_sidecar_tests.rs
index 12323a4b..f4a85f1c 100644
--- a/apps/axkdeck/src-tauri/src/server_sidecar_tests.rs
+++ b/apps/axkdeck/src-tauri/src/server_sidecar_tests.rs
@@ -76,6 +76,7 @@ fn connection(pid: u32) -> ConnectionFile {
 fn sidecar_arguments_never_expose_the_bearer_token() {
     let arguments = sidecar_arguments(
         std::path::Path::new("state"),
+        std::path::Path::new("config/tphzz/axkdeck/axklib-server/workspaces.json"),
         std::path::Path::new("state/connection.json"),
     );
     let rendered = arguments
@@ -86,6 +87,9 @@ fn sidecar_arguments_never_expose_the_bearer_token() {
     assert!(!rendered.contains("--token"));
     assert!(!rendered.contains("--config"));
     assert!(rendered.contains("--connection-file"));
+    assert!(
+        rendered.contains("--workspace-store config/tphzz/axkdeck/axklib-server/workspaces.json")
+    );
     assert!(rendered.contains("--port 0"));
     assert!(rendered.contains(&format!("--parent-pid {}", std::process::id())));
 }
@@ -94,6 +98,7 @@ fn sidecar_arguments_never_expose_the_bearer_token() {
 fn sidecar_arguments_allow_tauri_development_and_packaged_origins() {
     let arguments = sidecar_arguments(
         std::path::Path::new("state"),
+        std::path::Path::new("config/workspaces.json"),
         std::path::Path::new("state/connection.json"),
     );
     let rendered = arguments
diff --git a/apps/axkdeck/src-tauri/src/settings_paths.rs b/apps/axkdeck/src-tauri/src/settings_paths.rs
new file mode 100644
index 00000000..5c21a082
--- /dev/null
+++ b/apps/axkdeck/src-tauri/src/settings_paths.rs
@@ -0,0 +1,42 @@
+use std::path::{Path, PathBuf};
+
+const VENDOR_DIRECTORY: &str = "tphzz";
+const PRODUCT_DIRECTORY: &str = "axkdeck";
+
+pub struct SettingsPaths {
+    pub axkdeck_settings: PathBuf,
+    pub sidecar_workspace_store: PathBuf,
+}
+
+impl SettingsPaths {
+    pub fn from_config_directory(config_directory: &Path) -> Self {
+        let root = config_directory
+            .join(VENDOR_DIRECTORY)
+            .join(PRODUCT_DIRECTORY);
+        Self {
+            axkdeck_settings: root.join("settings.json"),
+            sidecar_workspace_store: root.join("axklib-server").join("workspaces.json"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use super::SettingsPaths;
+
+    #[test]
+    fn settings_files_separate_axkdeck_from_its_sidecar_store() {
+        let paths = SettingsPaths::from_config_directory(Path::new("config"));
+
+        assert_eq!(
+            paths.axkdeck_settings,
+            Path::new("config/tphzz/axkdeck/settings.json")
+        );
+        assert_eq!(
+            paths.sidecar_workspace_store,
+            Path::new("config/tphzz/axkdeck/axklib-server/workspaces.json")
+        );
+    }
+}
diff --git a/apps/axkdeck/src-tauri/tauri.linux.conf.json b/apps/axkdeck/src-tauri/tauri.linux.conf.json
index a18f9b62..dca4de4c 100644
--- a/apps/axkdeck/src-tauri/tauri.linux.conf.json
+++ b/apps/axkdeck/src-tauri/tauri.linux.conf.json
@@ -1,5 +1,17 @@
 {
   "bundle": {
+    "linux": {
+      "deb": {
+        "depends": [
+          "libc++1-18",
+          "libc++abi1-18",
+          "libunwind-18"
+        ]
+      },
+      "rpm": {
+        "depends": ["libcxx", "llvm-libunwind"]
+      }
+    },
     "targets": ["deb", "rpm"]
   }
 }
diff --git a/apps/axkdeck/src-tauri/tests/build_support_test.rs b/apps/axkdeck/src-tauri/tests/build_support_test.rs
index d94457fe..15ae5d01 100644
--- a/apps/axkdeck/src-tauri/tests/build_support_test.rs
+++ b/apps/axkdeck/src-tauri/tests/build_support_test.rs
@@ -131,6 +131,50 @@ fn build_identity_accepts_a_windows_line_ending() {
     std::fs::remove_dir_all(directory).expect("remove test directory");
 }
 
+#[test]
+fn build_identity_accepts_version_branch_prerelease_metadata() {
+    let directory = temporary_directory("version-branch");
+    std::fs::create_dir_all(&directory).expect("create test directory");
+    let metadata = directory.join("version_metadata.json");
+    let package = directory.join("package_basename.txt");
+    std::fs::write(
+        &metadata,
+        r#"{"schema_version":1,"semantic_version":"0.3.6-pre","project_version":"0.3.6","major":0,"minor":3,"patch":6,"release_tag":"","is_release":false,"is_prerelease":true}"#,
+    )
+    .expect("write version metadata");
+    std::fs::write(&package, "axklib-0.3.6-pre-a1b2c3d\n").expect("write package basename");
+
+    let identity =
+        build_support::read_build_identity(&metadata, &package).expect("read build identity");
+    assert_eq!(identity.semantic_version, "0.3.6-pre");
+    assert_eq!(identity.project_version, "0.3.6");
+    assert_eq!(identity.source_identity, "0.3.6-pre-a1b2c3d");
+    assert!(!identity.is_release);
+
+    std::fs::remove_dir_all(directory).expect("remove test directory");
+}
+
+#[test]
+fn build_identity_accepts_a_release_tag_without_v_prefix() {
+    let directory = temporary_directory("unprefixed-tag");
+    std::fs::create_dir_all(&directory).expect("create test directory");
+    let metadata = directory.join("version_metadata.json");
+    let package = directory.join("package_basename.txt");
+    std::fs::write(
+        &metadata,
+        r#"{"schema_version":1,"semantic_version":"1.2.3","project_version":"1.2.3","major":1,"minor":2,"patch":3,"release_tag":"1.2.3","is_release":true,"is_prerelease":false}"#,
+    )
+    .expect("write version metadata");
+    std::fs::write(&package, "axklib-1.2.3-a1b2c3d\n").expect("write package basename");
+
+    let identity =
+        build_support::read_build_identity(&metadata, &package).expect("read build identity");
+    assert_eq!(identity.release_tag, "1.2.3");
+    assert!(identity.is_release);
+
+    std::fs::remove_dir_all(directory).expect("remove test directory");
+}
+
 #[test]
 fn inconsistent_development_identity_is_rejected() {
     let directory = temporary_directory("invalid");
diff --git a/apps/axkdeck/src/AllocationInspector.svelte b/apps/axkdeck/src/AllocationInspector.svelte
index ffa0c161..26d94a33 100644
--- a/apps/axkdeck/src/AllocationInspector.svelte
+++ b/apps/axkdeck/src/AllocationInspector.svelte
@@ -8,6 +8,7 @@
         allocationExportFilename,
         allocationSpaceStatistic,
         formatAllocationBytes,
+        resolveAllocationServerConnection,
         saveAllocationMap,
     } from './lib/allocationInspector';
 
@@ -72,12 +73,12 @@
             error = 'This allocation inspector link is incomplete.';
             return;
         }
-        const connection = window.__AXKLIB_SERVER__;
-        if (!connection) {
-            error = 'No axklib-server connection is available.';
-            return;
-        }
         try {
+            const connection = await resolveAllocationServerConnection();
+            if (!connection) {
+                error = 'No axklib-server connection is available.';
+                return;
+            }
             const client = new AxklibHttpApiClient(connection);
             const parameters = new URLSearchParams({
                 partitionIndex: String(partitionIndex),
diff --git a/apps/axkdeck/src/App.svelte b/apps/axkdeck/src/App.svelte
index 8bd9db0e..ffaefe45 100644
--- a/apps/axkdeck/src/App.svelte
+++ b/apps/axkdeck/src/App.svelte
@@ -22,6 +22,7 @@
     import { SequenceImportWorkflow } from './features/import/sequenceWorkflow.svelte';
     import { Tx16wImportWorkflow } from './features/import/tx16wWorkflow.svelte';
     import { ImageSessionWorkflow } from './features/image-session/workflow.svelte';
+    import { createImageTreeActionHandler } from './features/image-session/treeActions';
     import { ExtentLayoutRepairWorkflow } from './features/image-session/extentLayoutRepairWorkflow.svelte';
     import { JobController } from './features/jobs/actions';
     import { MutationWorkflow } from './features/mutation/workflow.svelte';
@@ -30,8 +31,8 @@
     import { workspaceTabs } from './features/workspace/tabs';
     import ExperimentalWarningDialog from './lib/components/ExperimentalWarningDialog.svelte';
     import ImageIntegrityDialog from './lib/components/ImageIntegrityDialog.svelte';
+    import WorkspaceGuard from './lib/components/WorkspaceGuard.svelte';
     import { createTransport } from './lib/createTransport';
-    import { openAllocationInspector } from './lib/allocationInspector';
     import type { RemoteServerSettingsInput, RemoteServerSettingsView } from './lib/serverSettings';
     import { reportMutationTiming } from './lib/diagnostics';
     import {
@@ -40,14 +41,7 @@
         type PackageExportSelectionState,
     } from './lib/objectSelection';
     import { userFacingMessage } from './lib/userFacingMessage';
-    import type {
-        DiskTreeItem,
-        InspectorSelection,
-        PackageExportObject,
-        PackageExportSelection,
-        ImageTreeAction,
-        WorkspaceView,
-    } from './lib/types';
+    import type { InspectorSelection, PackageExportObject, PackageExportSelection, WorkspaceView } from './lib/types';
 
     let {
         interfaceScaling = null,
@@ -163,7 +157,7 @@
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
         pickerHistory: packagePickerHistory,
         mutationsAvailable: () => imageSessionWorkflow.packageImportAvailable,
-        selectedSource: () => imageSessionWorkflow.selectedSource,
+        selectedSource: () => imageSessionWorkflow.importDestinationSource(),
         sourceItems: () => imageSessionWorkflow.sourceItems,
     });
     const packageBatchImportWorkflow = new PackageBatchImportWorkflow({
@@ -219,7 +213,7 @@
         imageFormat: () => imageSessionWorkflow.imageFormat,
         mutationsAvailable: () => mutationWorkflow.volumeAvailable,
         selectedSource: () => imageSessionWorkflow.selectedSource,
-        setSelectedSource: (item) => (imageSessionWorkflow.selectedSource = item),
+        setSelectedSource: (item) => imageSessionWorkflow.selectSource(item),
         sourceItems: () => imageSessionWorkflow.sourceItems,
         activeVolumeId: () => catalog.activeVolumeId,
         sampleBanks: () => catalog.sampleBanks,
@@ -241,7 +235,7 @@
         imageLocation: () => imageSessionWorkflow.location,
         mutationsAvailable: () => mutationWorkflow.objectRenameAvailable,
         selectedSource: () => imageSessionWorkflow.selectedSource,
-        setSelectedSource: (item) => (imageSessionWorkflow.selectedSource = item),
+        setSelectedSource: (item) => imageSessionWorkflow.selectSource(item),
         sourceItems: () => imageSessionWorkflow.sourceItems,
         activeVolumeId: () => catalog.activeVolumeId,
         sequences: () => catalog.sequences,
@@ -284,9 +278,22 @@
         sessionId: () => imageSessionWorkflow.sessionId,
         imageFormat: () => imageSessionWorkflow.imageFormat,
         mutationsAvailable: () => mutationWorkflow.volumeAvailable,
-        selectedSource: () => imageSessionWorkflow.selectedSource,
+        selectedSource: () => imageSessionWorkflow.importDestinationSource(),
         setStatus: (status) => imageSessionWorkflow.setStatus(status),
     });
+    const requestImageAction = createImageTreeActionHandler({
+        transport,
+        imageSession: imageSessionWorkflow,
+        mutation: mutationWorkflow,
+        directComputer: directComputerWorkflow,
+        packageBatchImport: packageBatchImportWorkflow,
+        exports: exportWorkflow,
+        volumePackages: volumePackageExportWorkflow,
+        volumeFloppies: volumeFloppyExportWorkflow,
+        mediaExports: mediaExportWorkflow,
+        isDesktop,
+        exportAudio: requestAudioExport,
+    });
     imageSessionWorkflow.connect({
         catalog,
         audition: auditionWorkflow,
@@ -333,6 +340,7 @@
     });
 
     const selectedProgram = $derived(programs.find((item) => item.objectId === catalog.selectedProgramId));
+    const activeWorkspaceId = $derived(imageSessionWorkflow.location?.reference.rootId ?? null);
     const selectedBank = $derived(sampleBanks.find((item) => item.objectId === catalog.selectedBankId));
     const selectedSample = $derived(samples.find((item) => item.objectId === catalog.selectedSampleId));
     const auditionableSampleObjectIds = $derived(auditionWorkflow.auditionableSampleObjectIds);
@@ -341,7 +349,6 @@
         hasOpenAppDialog({
             pickerRequest,
             imageSession: imageSessionWorkflow,
-            workspaceManagerOpen,
             connectionSettings,
             mutation: mutationWorkflow,
             packageImport: packageImportWorkflow,
@@ -408,92 +415,6 @@
         }
     });
 
-    function requestImageAction(item: DiskTreeItem, action: ImageTreeAction): void {
-        if (item.partitionIndex === undefined) return;
-        if (action === 'inspect-allocation') {
-            const sessionId = imageSessionWorkflow.sessionId;
-            if (
-                !isDesktop ||
-                sessionId === null ||
-                !imageSessionWorkflow.allocationInspectionAvailable ||
-                item.kind !== 'partition'
-            )
-                return;
-            imageSessionWorkflow.selectedSource = item;
-            void transport
-                .allocationMapReference(sessionId)
-                .then((reference) =>
-                    openAllocationInspector({
-                        ...reference,
-                        partitionIndex: item.partitionIndex!,
-                        partitionName: item.name,
-                    }),
-                )
-                .catch((error) => imageSessionWorkflow.setStatus(userFacingMessage(error)));
-            return;
-        }
-        if (action === 'import-package') {
-            if (!imageSessionWorkflow.packageImportAvailable || item.kind !== 'volume') return;
-            imageSessionWorkflow.selectedSource = item;
-            directComputerWorkflow.importPackage(packageImportWorkflow, item);
-            return;
-        }
-        if (action === 'import-packages') {
-            if (!imageSessionWorkflow.packageImportAvailable || item.kind !== 'partition') return;
-            imageSessionWorkflow.selectedSource = item;
-            directComputerWorkflow.importVolumePackages(packageBatchImportWorkflow, item);
-            return;
-        }
-        if (action === 'export-package') {
-            if (!imageSessionWorkflow.packageExportAvailable || item.kind !== 'volume') return;
-            imageSessionWorkflow.selectedSource = item;
-            directComputerWorkflow.exportPackage(exportWorkflow, [
-                {
-                    kind: 'VOLUME',
-                    contentId: item.id,
-                    partitionIndex: item.partitionIndex!,
-                    volumeName: item.name,
-                    name: item.name,
-                    typeLabel: 'Volume',
-                },
-            ]);
-            return;
-        }
-        if (action === 'export-volume-packages') {
-            if (!imageSessionWorkflow.volumePackageExportAvailable || item.kind !== 'partition') return;
-            imageSessionWorkflow.selectedSource = item;
-            void directComputerWorkflow.exportVolumePackages(volumePackageExportWorkflow, item);
-            return;
-        }
-        if (action === 'export-volume-floppies') {
-            if (!imageSessionWorkflow.volumeFloppyExportAvailable || item.kind !== 'partition') return;
-            imageSessionWorkflow.selectedSource = item;
-            void directComputerWorkflow.exportVolumeFloppies(volumeFloppyExportWorkflow, item);
-            return;
-        }
-        if (action === 'export-sfz') {
-            if (!imageSessionWorkflow.audioExportAvailable || item.kind !== 'volume') return;
-            imageSessionWorkflow.selectedSource = item;
-            void requestAudioExport([
-                {
-                    kind: 'VOLUME',
-                    contentId: item.id,
-                    partitionIndex: item.partitionIndex,
-                    volumeName: item.name,
-                    name: item.name,
-                    typeLabel: 'Volume',
-                },
-            ]);
-            return;
-        }
-        if (action === 'export-cdrom' || action === 'export-floppy') {
-            if (!imageSessionWorkflow.mediaConversionAvailable) return;
-            imageSessionWorkflow.selectedSource = item;
-            void directComputerWorkflow.exportMedia(mediaExportWorkflow, item);
-            return;
-        }
-        if (mutationWorkflow.requestVolumeAction(item, action)) imageSessionWorkflow.selectedSource = item;
-    }
     function requestObjectPackageExport(items: PackageExportObject[]): void {
         if (
             !imageSessionWorkflow.packageExportAvailable ||
@@ -546,7 +467,6 @@
     async function saveRemoteConnection(input: RemoteServerSettingsInput): Promise<void> {
         await connectionActions.saveRemote(input);
     }
-
     async function switchToLocalConnection(): Promise<void> {
         await connectionActions.useLocal();
     }
@@ -580,6 +500,7 @@
     imageLocation={imageSessionWorkflow.location}
     sourceItems={imageSessionWorkflow.sourceItems}
     selectedSource={imageSessionWorkflow.selectedSource}
+    selectedVolumeIds={imageSessionWorkflow.volumeSelection.items.map((item) => item.id)}
     imageOpening={imageSessionWorkflow.opening}
     sessionId={imageSessionWorkflow.sessionId}
     {catalog}
@@ -613,13 +534,15 @@
     sequenceExportAvailable={imageSessionWorkflow.sequenceExportAvailable}
     mediaConversionAvailable={imageSessionWorkflow.mediaConversionAvailable}
     allocationInspectionAvailable={imageSessionWorkflow.allocationInspectionAvailable}
+    samplerOrderingEnabled={imageSessionWorkflow.imageFormat === 'sfs'}
     openConnectionSettings={() => void openConnectionSettings()}
     openImage={() => void imageSessionWorkflow.chooseAndOpen()}
     createImage={() => void imageSessionWorkflow.chooseHardDiskDirectory()}
     closeImage={() => void imageSessionWorkflow.close().catch(() => undefined)}
     showImageIntegrity={() => void imageSessionWorkflow.showIntegrity()}
     manageLocations={() => (workspaceManagerOpen = true)}
-    selectSource={(item) => imageSessionWorkflow.selectSource(item)}
+    selectSource={(item, mode, visibleVolumes) => imageSessionWorkflow.selectTreeSource(item, mode, visibleVolumes)}
+    selectSourceForContext={(item, visibleVolumes) => imageSessionWorkflow.selectSourceForContext(item, visibleVolumes)}
     imageAction={requestImageAction}
     selectWorkspace={(view) => auditionWorkflow.selectWorkspaceView(view)}
     exportPackage={requestObjectPackageExport}
@@ -637,7 +560,7 @@
     <ExperimentalWarningDialog onacknowledge={() => (experimentalWarningAcknowledged = true)} />
 {/if}
 
-{#if imageSessionWorkflow.integrityDialogOpen}
+{#if !experimentalWarningOpen && imageSessionWorkflow.integrityDialogOpen}
     <ImageIntegrityDialog
         issues={imageSessionWorkflow.integrityIssues}
         loading={imageSessionWorkflow.integrityLoading}
@@ -651,7 +574,9 @@
     />
 {/if}
 
-{#if appDialogsOpen}
+<WorkspaceGuard enabled={!experimentalWarningOpen} bind:open={workspaceManagerOpen} {activeWorkspaceId} />
+
+{#if !experimentalWarningOpen && appDialogsOpen}
     {#await import('./features/dialogs/AppDialogs.svelte') then dialogs}
         {@const AppDialogs = dialogs.default}
         <AppDialogs
@@ -669,9 +594,6 @@
             hardDiskDirectory={imageSessionWorkflow.hardDiskDirectory}
             finishHardDisk={(file) => imageSessionWorkflow.finishHardDiskCreation(file)}
             cancelHardDisk={() => imageSessionWorkflow.cancelHardDiskCreation()}
-            {workspaceManagerOpen}
-            activeWorkspaceId={imageSessionWorkflow.location?.reference.rootId ?? null}
-            closeWorkspaceManager={() => (workspaceManagerOpen = false)}
             {connectionSettings}
             {saveRemoteConnection}
             {switchToLocalConnection}
diff --git a/apps/axkdeck/src/App.test.ts b/apps/axkdeck/src/App.test.ts
index 59308057..536b3355 100644
--- a/apps/axkdeck/src/App.test.ts
+++ b/apps/axkdeck/src/App.test.ts
@@ -230,6 +230,68 @@ describe('App panel layout', () => {
         expect(screen.getByRole('dialog', { name: 'Experimental software' })).toBeTruthy();
     });
 
+    it('opens storage setup when the local sidecar has no configured workspace', async () => {
+        window.__AXKLIB_SERVER__ = {
+            baseUrl: 'http://127.0.0.1:7331/api/v1',
+            bearerToken: 'test-token',
+            mode: 'local',
+        };
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+            new Response(
+                JSON.stringify({
+                    data: {
+                        state: 'NO_AVAILABLE_WORKSPACE',
+                        revision: 0,
+                        workspaces: [],
+                        configurationIssue: null,
+                    },
+                }),
+                { status: 200, headers: { 'content-type': 'application/json' } },
+            ),
+        );
+        const rendered = render(App, { props: { initialExperimentalWarningOpen: false } });
+
+        expect(await screen.findByRole('dialog', { name: 'Storage locations' })).toBeTruthy();
+        expect(screen.getByText('Choose a directory before opening or creating sampler images.')).toBeTruthy();
+
+        rendered.unmount();
+        fetchSpy.mockRestore();
+    });
+
+    it('defers storage setup until the experimental warning is acknowledged', async () => {
+        window.__AXKLIB_SERVER__ = {
+            baseUrl: 'http://127.0.0.1:7331/api/v1',
+            bearerToken: 'test-token',
+            mode: 'local',
+        };
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+            new Response(
+                JSON.stringify({
+                    data: {
+                        state: 'NO_AVAILABLE_WORKSPACE',
+                        revision: 0,
+                        workspaces: [],
+                        configurationIssue: null,
+                    },
+                }),
+                { status: 200, headers: { 'content-type': 'application/json' } },
+            ),
+        );
+        const rendered = render(App);
+
+        await vi.dynamicImportSettled();
+        expect(screen.getByRole('dialog', { name: 'Experimental software' })).toBeTruthy();
+        expect(screen.queryByRole('dialog', { name: 'Storage locations' })).toBeNull();
+        expect(fetchSpy).not.toHaveBeenCalled();
+
+        await fireEvent.click(screen.getByRole('button', { name: 'I understand' }));
+        expect(await screen.findByRole('dialog', { name: 'Storage locations' })).toBeTruthy();
+        expect(fetchSpy).toHaveBeenCalledOnce();
+
+        rendered.unmount();
+        fetchSpy.mockRestore();
+    });
+
     it('opens About from the brand and reuses the authoritative build information', async () => {
         renderAcknowledgedApp();
         const brand = screen.getByRole('button', { name: 'About axkdeck' });
@@ -239,7 +301,8 @@ describe('App panel layout', () => {
         await fireEvent.click(brand);
         const firstDialog = await screen.findByRole('dialog', { name: 'About axkdeck' });
         expect(within(firstDialog).getByText('0.4.0')).toBeTruthy();
-        expect(within(firstDialog).getByText('v0.4.0-1234567')).toBeTruthy();
+        expect(within(firstDialog).queryByText('v0.4.0-1234567')).toBeNull();
+        expect(within(firstDialog).queryByText('Build')).toBeNull();
         expect(mocks.desktopBuildInfo).toHaveBeenCalledOnce();
 
         await fireEvent.click(within(firstDialog).getByRole('button', { name: 'Close' }));
@@ -861,6 +924,8 @@ describe('App panel layout', () => {
             imageId: 'image-1',
             revision: 1,
             targetObjectIds: [sample.key],
+            referrerObjectIds: [],
+            cleanupObjectIds: [],
             selectedObjectIds: [sample.key],
             impacts: [
                 {
@@ -872,6 +937,7 @@ describe('App panel layout', () => {
                     volumeName: 'Piano',
                     role: 'TARGET',
                     status: 'REQUIRED',
+                    requested: true,
                     selected: true,
                     storedSizeBytes: 512,
                     freedClusters: 1,
@@ -887,6 +953,7 @@ describe('App panel layout', () => {
                     volumeName: 'Piano',
                     role: 'DEPENDENCY',
                     status: 'OPTIONAL',
+                    requested: false,
                     selected: false,
                     storedSizeBytes: 4096,
                     freedClusters: 4,
@@ -902,9 +969,10 @@ describe('App panel layout', () => {
         };
         const selectedInspection = {
             ...inspection,
+            cleanupObjectIds: ['wave-1'],
             selectedObjectIds: [sample.key, 'wave-1'],
             impacts: inspection.impacts.map((impact) =>
-                impact.objectId === 'wave-1' ? { ...impact, selected: true } : impact,
+                impact.objectId === 'wave-1' ? { ...impact, requested: true, selected: true } : impact,
             ),
             estimatedFreedBytes: 5120,
             estimatedFreedClusters: 5,
@@ -938,12 +1006,14 @@ describe('App panel layout', () => {
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Delete' }));
         await vi.waitFor(() => expect(screen.getByRole('dialog', { name: 'Delete Sample' })).toBeTruthy());
         await fireEvent.click(screen.getByRole('checkbox', { name: 'Also delete all (1)' }));
-        await vi.waitFor(() => expect(mocks.inspectObjectDeletion).toHaveBeenCalledWith(17, [sample.key], ['wave-1']));
+        await vi.waitFor(() =>
+            expect(mocks.inspectObjectDeletion).toHaveBeenCalledWith(17, [sample.key], [], ['wave-1']),
+        );
         await fireEvent.click(screen.getByRole('button', { name: 'Delete 2 objects' }));
 
         await vi.waitFor(() => expect(mocks.startObjectDeletion).toHaveBeenCalledOnce());
         expect(mocks.inspectObjectDeletion).toHaveBeenCalledTimes(3);
-        expect(mocks.startObjectDeletion).toHaveBeenCalledWith(17, [sample.key], ['wave-1']);
+        expect(mocks.startObjectDeletion).toHaveBeenCalledWith(17, [sample.key], [], ['wave-1']);
         await vi.waitFor(() => expect(mocks.waitForJob).toHaveBeenCalledWith(55, expect.any(Function)));
         await vi.waitFor(() => expect(mocks.refreshImage).toHaveBeenCalledWith(17));
         expect(screen.getByRole('dialog', { name: 'Delete Sample' })).toBeTruthy();
@@ -1020,6 +1090,8 @@ describe('App panel layout', () => {
             imageId: 'image-1',
             revision: 1,
             targetObjectIds: ['wave-unused-a'],
+            referrerObjectIds: [],
+            cleanupObjectIds: [],
             selectedObjectIds: ['wave-unused-a'],
             impacts: [
                 {
@@ -1031,6 +1103,7 @@ describe('App panel layout', () => {
                     volumeName: volume.name,
                     role: 'TARGET',
                     status: 'REQUIRED',
+                    requested: true,
                     selected: true,
                     storedSizeBytes: 4096,
                     freedClusters: 4,
@@ -1071,9 +1144,9 @@ describe('App panel layout', () => {
         await vi.waitFor(() => expect(mocks.inspectWaveDataOrphans).toHaveBeenCalledTimes(2));
         expect(mocks.inspectWaveDataOrphans).toHaveBeenNthCalledWith(1, 17, volume.id);
         expect(mocks.inspectWaveDataOrphans).toHaveBeenNthCalledWith(2, 17, volume.id);
-        expect(mocks.inspectObjectDeletion).toHaveBeenCalledWith(17, ['wave-unused-a'], []);
+        expect(mocks.inspectObjectDeletion).toHaveBeenCalledWith(17, ['wave-unused-a'], [], []);
         await vi.waitFor(() => expect(mocks.startObjectDeletion).toHaveBeenCalledOnce());
-        expect(mocks.startObjectDeletion).toHaveBeenCalledWith(17, ['wave-unused-a'], []);
+        expect(mocks.startObjectDeletion).toHaveBeenCalledWith(17, ['wave-unused-a'], [], []);
         await vi.waitFor(() => expect(mocks.refreshImage).toHaveBeenCalledWith(17));
         await vi.waitFor(() => expect(screen.queryByRole('dialog', { name: 'Clean up Wave Data' })).toBeNull());
     });
@@ -1212,7 +1285,7 @@ describe('App panel layout', () => {
         expect(screen.queryByRole('button', { name: 'New folder' })).toBeNull();
     });
 
-    it('continues from package verification into import planning without proxy identity checks', async () => {
+    it('opens batch package import on a volume with that existing volume selected', async () => {
         const volume = {
             id: 'volume-1',
             name: 'My Volume',
@@ -1248,6 +1321,7 @@ describe('App panel layout', () => {
             sourceMediaKind: 'SFS',
             valid: true,
             payloadsVerified: true,
+            totalPayloadBytes: 0,
             roots: [{ kind: 'VOLUME', displayName: 'Grand Piano', nodeIds: [] }],
             objects: [],
             relationships: [],
@@ -1282,6 +1356,7 @@ describe('App panel layout', () => {
             programAssignmentAdjustments: [],
             programSlotPlacements: [],
             allocation: [],
+            sfsIndexCapacity: [],
         });
         renderAcknowledgedApp();
 
@@ -1301,14 +1376,34 @@ describe('App panel layout', () => {
             nextCursor: null,
         });
         await fireEvent.contextMenu(screen.getByRole('button', { name: /My Volume/ }));
-        await fireEvent.click(screen.getByRole('menuitem', { name: 'Import package…' }));
-        const importDialog = await screen.findByRole('dialog', { name: 'Import axklib package' });
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Import' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Import packages…' }));
+        const importDialog = await screen.findByRole('dialog', { name: 'Import packages' });
         await fireEvent.click(within(importDialog).getByRole('button', { name: /Storage location/ }));
-        const picker = await screen.findByRole('dialog', { name: 'Choose axklib package' });
-        expect(screen.queryByRole('dialog', { name: 'Import axklib package' })).toBeNull();
+        const picker = await screen.findByRole('dialog', { name: 'Choose axklib packages' });
+        expect(screen.queryByRole('dialog', { name: 'Import packages' })).toBeNull();
         expect(screen.getAllByRole('dialog')).toHaveLength(1);
         await fireEvent.click(await within(picker).findByText('Yamaha'));
         await fireEvent.click(await within(picker).findByText('GrPiano Fazioli.axkvol'));
+        await fireEvent.click(within(picker).getByRole('button', { name: 'Select 1 file' }));
+
+        const plannedDialog = await screen.findByRole('dialog', { name: 'Import packages' });
+        expect(
+            (await within(plannedDialog).findByRole('button', { name: 'One volume' })).getAttribute('aria-pressed'),
+        ).toBe('true');
+        expect(
+            (await within(plannedDialog).findByRole('button', { name: 'Existing' })).getAttribute('aria-pressed'),
+        ).toBe('true');
+        expect(
+            (
+                (await within(plannedDialog).findByRole('combobox', {
+                    name: 'Destination volume',
+                })) as HTMLInputElement
+            ).value,
+        ).toBe('My Volume');
+        expect(mocks.planImagePackageImport).not.toHaveBeenCalled();
+
+        await fireEvent.click(within(plannedDialog).getByRole('button', { name: 'Check conflicts' }));
 
         await vi.waitFor(() =>
             expect(mocks.planImagePackageImport).toHaveBeenCalledWith(
@@ -1588,8 +1683,9 @@ describe('App panel layout', () => {
 
         await chooseNestedImage();
         await fireEvent.contextMenu(await screen.findByRole('button', { name: /Object directory/ }));
-        expect(screen.queryByRole('menuitem', { name: 'Import package…' })).toBeNull();
-        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export package…' }));
+        expect(screen.queryByRole('menuitem', { name: 'Import' })).toBeNull();
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export volume package…' }));
 
         const dialog = await screen.findByRole('dialog', { name: 'Export axklib package' });
         expect(within(dialog).getByText('Export “Object directory”')).toBeTruthy();
diff --git a/apps/axkdeck/src/app.css b/apps/axkdeck/src/app.css
index c71db098..60ac2419 100644
--- a/apps/axkdeck/src/app.css
+++ b/apps/axkdeck/src/app.css
@@ -29,8 +29,13 @@
   --density-table-header: 20px;
   --density-metadata-row: 22px;
   --density-gap: 4px;
+  --dialog-title-font-size: 13px;
+  --dialog-body-font-size: 11px;
+  --dialog-section-font-size: 11px;
   --dialog-control-font-size: 11px;
   --dialog-label-font-size: 10px;
+  --dialog-table-header-font-size: 10px;
+  --dialog-metadata-font-size: 10px;
   --dialog-option-metadata-font-size: 10px;
   --overlay-scrollbar-clearance: 16px;
   --contained-playback-clearance: 10px;
@@ -741,7 +746,7 @@ input:focus-visible {
   width: 100%;
   min-width: 0;
   min-height: var(--density-row);
-  grid-template-columns: 46px minmax(0, 1fr);
+  grid-template-columns: 46px minmax(0, 1fr) minmax(110px, 180px);
   align-items: center;
   gap: 8px;
   padding: 2px 7px;
@@ -787,6 +792,16 @@ input:focus-visible {
   white-space: nowrap;
 }
 
+.object-size-summary {
+  min-width: 0;
+  overflow: hidden;
+  color: var(--color-text-muted);
+  font-size: 9px;
+  text-align: right;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 .program-system-info {
   position: relative;
   display: flex;
@@ -1309,6 +1324,8 @@ input:focus-visible {
   border-radius: 8px;
   background: var(--color-panel);
   box-shadow: 0 24px 80px rgb(0 0 0 / 55%);
+  font-size: var(--dialog-body-font-size);
+  line-height: 1.35;
 }
 
 .dialog-shell-wide {
@@ -1352,7 +1369,102 @@ input:focus-visible {
 .dialog-header h2 {
   margin: 0;
   color: var(--color-text-strong);
-  font-size: 13px;
+  font-size: var(--dialog-title-font-size);
+}
+
+.dialog-checkbox {
+  display: grid;
+  width: 14px;
+  height: 14px;
+  flex: none;
+  margin: 0;
+  padding: 0;
+  overflow: hidden;
+  appearance: none;
+  place-content: center;
+  color: #fff;
+  border: 1px solid var(--color-border);
+  border-radius: 2px;
+  background: var(--color-bg-deep);
+  cursor: pointer;
+}
+
+.dialog-checkbox::before {
+  width: 4px;
+  height: 7px;
+  content: '';
+  border: solid currentcolor;
+  border-width: 0 1.5px 1.5px 0;
+  transform: translateY(-0.75px) rotate(45deg) scale(0);
+}
+
+.dialog-checkbox:checked,
+.dialog-checkbox:indeterminate {
+  border-color: var(--color-accent);
+  background: var(--color-accent);
+}
+
+.dialog-checkbox:checked::before {
+  transform: translateY(-0.75px) rotate(45deg) scale(1);
+}
+
+.dialog-checkbox:indeterminate::before {
+  width: 7px;
+  height: 0;
+  border: 0;
+  border-top: 1.5px solid currentcolor;
+  transform: none;
+}
+
+.dialog-checkbox:disabled {
+  cursor: default;
+  opacity: 0.5;
+}
+
+.dialog-segmented-control {
+  display: grid;
+  grid-auto-flow: column;
+  overflow: hidden;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-bg-deep);
+}
+
+.dialog-segmented-control > button {
+  min-width: 0;
+  min-height: 27px;
+  padding: 0 10px;
+  overflow: hidden;
+  color: var(--color-text-muted);
+  border: 0;
+  border-left: 1px solid var(--color-border);
+  border-radius: 0;
+  background: transparent;
+  cursor: pointer;
+  font-size: var(--dialog-table-header-font-size);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.dialog-segmented-control > button:first-child {
+  border-left: 0;
+}
+
+.dialog-segmented-control > button:focus-visible {
+  position: relative;
+  z-index: 1;
+  outline: 1px solid var(--color-accent);
+  outline-offset: -2px;
+}
+
+.dialog-segmented-control > button[aria-pressed='true'] {
+  color: #fff;
+  background: var(--color-accent-strong);
+}
+
+.dialog-segmented-control > button:disabled {
+  cursor: default;
+  opacity: 0.45;
 }
 
 .package-dialog {
@@ -1360,7 +1472,9 @@ input:focus-visible {
 }
 
 .package-dialog-content {
+  display: grid;
   min-height: 0;
+  gap: 12px;
   padding: 14px;
   overflow-y: auto;
 }
@@ -1377,14 +1491,14 @@ input:focus-visible {
 .package-plan-section h3 {
   margin: 0;
   color: var(--color-text-strong);
-  font-size: 12px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .import-source-choice > p,
 .package-source-choice > p {
   margin: 0 0 4px;
   color: var(--color-text-muted);
-  font-size: 11px;
+  font-size: var(--dialog-body-font-size);
 }
 
 .package-export-items {
@@ -1406,7 +1520,7 @@ input:focus-visible {
 .package-export-group h4 {
   margin: 0 0 2px;
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
   font-weight: 600;
 }
 
@@ -1424,7 +1538,7 @@ input:focus-visible {
 .package-export-items strong {
   min-width: 0;
   overflow: hidden;
-  font-size: 11px;
+  font-size: var(--dialog-body-font-size);
   text-overflow: ellipsis;
   white-space: nowrap;
 }
@@ -1432,7 +1546,7 @@ input:focus-visible {
 .package-export-items span {
   flex: none;
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .source-choice-button {
@@ -1454,36 +1568,7 @@ input:focus-visible {
 }
 
 .audio-export-format {
-  display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
-  overflow: hidden;
-  border: 1px solid var(--color-border);
-  border-radius: 5px;
-}
-
-.audio-export-format button {
-  min-height: 32px;
-  padding: 0 10px;
-  color: var(--color-text-muted);
-  border: 0;
-  border-right: 1px solid var(--color-border);
-  background: transparent;
-  cursor: pointer;
-  font-size: 11px;
-}
-
-.audio-export-format button:last-child {
-  border-right: 0;
-}
-
-.audio-export-format button.active {
-  color: var(--color-text-strong);
-  background: var(--color-selection);
-}
-
-.audio-export-format button:disabled {
-  cursor: default;
-  opacity: 0.45;
 }
 
 .audio-export-guidance,
@@ -1505,12 +1590,12 @@ input:focus-visible {
 
 .source-choice-button strong {
   color: var(--color-text-strong);
-  font-size: 12px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .source-choice-button small {
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .package-source-summary {
@@ -1518,7 +1603,6 @@ input:focus-visible {
   align-items: center;
   justify-content: space-between;
   gap: 12px;
-  margin-bottom: 12px;
   padding-bottom: 10px;
   border-bottom: 1px solid var(--color-border);
 }
@@ -1531,14 +1615,14 @@ input:focus-visible {
 
 .package-source-summary small {
   color: var(--color-text-muted);
-  font-size: 9px;
+  font-size: var(--dialog-label-font-size);
   text-transform: uppercase;
 }
 
 .package-source-summary strong {
   overflow: hidden;
   color: var(--color-text-strong);
-  font-size: 12px;
+  font-size: var(--dialog-section-font-size);
   text-overflow: ellipsis;
   white-space: nowrap;
 }
@@ -1564,7 +1648,7 @@ input:focus-visible {
 
 .package-section-heading small {
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .package-tree {
@@ -1592,14 +1676,14 @@ input:focus-visible {
 .package-tree-row strong {
   overflow: hidden;
   color: var(--color-text-strong);
-  font-size: 11px;
+  font-size: var(--dialog-body-font-size);
   text-overflow: ellipsis;
   white-space: nowrap;
 }
 
 .package-tree-row small {
   color: var(--color-text-muted);
-  font-size: 9px;
+  font-size: var(--dialog-metadata-font-size);
   white-space: nowrap;
 }
 
@@ -1619,7 +1703,7 @@ input:focus-visible {
 .package-plan-summary dt,
 .package-plan-summary dd {
   margin: 0;
-  font-size: 10px;
+  font-size: var(--dialog-label-font-size);
 }
 
 .package-plan-summary dt {
@@ -1632,7 +1716,7 @@ input:focus-visible {
   gap: 6px;
   margin: 12px 0 0;
   color: #85d8ad;
-  font-size: 11px;
+  font-size: var(--dialog-body-font-size);
 }
 
 .opaque-sequence-choices {
@@ -1656,7 +1740,7 @@ input:focus-visible {
   max-width: 100%;
   padding: 0 4px;
   color: #e4c17c;
-  font-size: 11px;
+  font-size: var(--dialog-section-font-size);
   font-weight: 600;
   overflow-wrap: anywhere;
 }
@@ -1664,7 +1748,7 @@ input:focus-visible {
 .opaque-sequence-choices fieldset > p {
   margin: 0;
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
   line-height: 1.4;
 }
 
@@ -1691,12 +1775,12 @@ input:focus-visible {
 
 .opaque-sequence-choices strong {
   color: var(--color-text-strong);
-  font-size: 10px;
+  font-size: var(--dialog-label-font-size);
 }
 
 .opaque-sequence-choices small {
   color: var(--color-text-muted);
-  font-size: 9px;
+  font-size: var(--dialog-metadata-font-size);
   line-height: 1.35;
 }
 
@@ -1729,7 +1813,7 @@ input:focus-visible {
 
 .program-slot-placement-heading strong {
   color: var(--color-text-strong);
-  font-size: 11px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .program-slot-placement-heading small,
@@ -1737,7 +1821,7 @@ input:focus-visible {
 .program-slot-placements section > p {
   margin: 0;
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .program-slot-placements dl {
@@ -1755,7 +1839,7 @@ input:focus-visible {
 .program-slot-placements dt,
 .program-slot-placements dd {
   margin: 0;
-  font-size: 10px;
+  font-size: var(--dialog-label-font-size);
 }
 
 .program-slot-placements dt {
@@ -1778,7 +1862,7 @@ input:focus-visible {
 .program-slot-start span,
 .program-slot-exception span {
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-label-font-size);
 }
 
 .program-slot-start input,
@@ -1790,7 +1874,7 @@ input:focus-visible {
   border-radius: 4px;
   background: var(--color-surface);
   color: var(--color-text-strong);
-  font-size: 11px;
+  font-size: var(--dialog-control-font-size);
 }
 
 .package-conflicts {
@@ -1805,7 +1889,7 @@ input:focus-visible {
 
 .package-conflicts > strong {
   color: #e4c17c;
-  font-size: 11px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .package-conflicts label {
@@ -1815,7 +1899,7 @@ input:focus-visible {
 
 .package-conflicts label span {
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-label-font-size);
 }
 
 .package-conflicts input {
@@ -1826,7 +1910,7 @@ input:focus-visible {
   border-radius: 4px;
   background: var(--color-surface);
   color: var(--color-text-strong);
-  font-size: 11px;
+  font-size: var(--dialog-control-font-size);
 }
 
 .package-conflict-actions {
@@ -1839,7 +1923,7 @@ input:focus-visible {
 
 .package-conflict-actions small {
   color: #e4c17c;
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .package-conflict-actions .secondary-button {
@@ -1856,7 +1940,7 @@ input:focus-visible {
 
 .package-adjustments > strong {
   color: var(--color-text-strong);
-  font-size: 11px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .package-adjustments p {
@@ -1867,19 +1951,19 @@ input:focus-visible {
 
 .package-adjustments span {
   color: var(--color-text);
-  font-size: 10px;
+  font-size: var(--dialog-body-font-size);
 }
 
 .package-adjustments small {
   overflow-wrap: anywhere;
   color: var(--color-text-muted);
-  font-size: 9px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .package-warning {
   margin: 9px 0 0;
   color: #dfbd7b;
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .volume-action-dialog {
@@ -1907,14 +1991,14 @@ input:focus-visible {
 
 .destructive-summary strong {
   color: var(--color-text-strong);
-  font-size: 13px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .destructive-summary p,
 .deletion-notices p {
   margin: 0;
   color: var(--color-text-muted);
-  font-size: 11px;
+  font-size: var(--dialog-body-font-size);
   line-height: 1.45;
 }
 
@@ -1928,13 +2012,13 @@ input:focus-visible {
 .deletion-impact-section h3 {
   margin: 0;
   color: var(--color-text-strong);
-  font-size: 11px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .deletion-section-help {
   margin: -2px 0 0;
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
   line-height: 1.4;
 }
 
@@ -1948,7 +2032,7 @@ input:focus-visible {
   border-radius: 4px;
   background: rgb(255 255 255 / 3%);
   cursor: pointer;
-  font-size: 10px;
+  font-size: var(--dialog-label-font-size);
 }
 
 .deletion-blockers {
@@ -1995,53 +2079,6 @@ input:focus-visible {
   color: var(--color-text-muted);
 }
 
-.deletion-checkbox {
-  width: 16px;
-  height: 16px;
-  display: grid;
-  flex: none;
-  margin: 1px;
-  padding: 0;
-  appearance: none;
-  place-content: center;
-  color: #fff;
-  border: 1px solid var(--color-border);
-  border-radius: 3px;
-  background: var(--color-bg-deep);
-  cursor: pointer;
-}
-
-.deletion-checkbox::before {
-  width: 4px;
-  height: 7px;
-  content: "";
-  border: solid currentcolor;
-  border-width: 0 2px 2px 0;
-  transform: translateY(-1px) rotate(45deg) scale(0);
-}
-
-.deletion-checkbox:checked {
-  border-color: var(--color-accent);
-  background: var(--color-accent);
-}
-
-.deletion-checkbox:checked::before {
-  transform: translateY(-1px) rotate(45deg) scale(1);
-}
-
-.deletion-checkbox:indeterminate::before {
-  width: 8px;
-  height: 2px;
-  border: 0;
-  background: currentcolor;
-  transform: none;
-}
-
-.deletion-checkbox:disabled {
-  cursor: default;
-  opacity: 0.5;
-}
-
 .deletion-impact-icon {
   display: grid;
   width: 18px;
@@ -2070,7 +2107,7 @@ input:focus-visible {
 .deletion-impact-heading strong {
   overflow: hidden;
   color: var(--color-text-strong);
-  font-size: 11px;
+  font-size: var(--dialog-body-font-size);
   text-overflow: ellipsis;
   white-space: nowrap;
 }
@@ -2078,13 +2115,13 @@ input:focus-visible {
 .deletion-impact-heading small,
 .deletion-impact-copy > small {
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .deletion-outcome {
   margin-left: auto;
   color: var(--color-text-muted);
-  font-size: 9px;
+  font-size: var(--dialog-label-font-size);
   text-transform: uppercase;
 }
 
@@ -2106,14 +2143,14 @@ input:focus-visible {
 .deletion-footer-summary strong {
   overflow: hidden;
   color: var(--color-text-strong);
-  font-size: 10px;
+  font-size: var(--dialog-section-font-size);
   text-overflow: ellipsis;
   white-space: nowrap;
 }
 
 .deletion-footer-summary span {
   color: var(--color-text-muted);
-  font-size: 9px;
+  font-size: var(--dialog-metadata-font-size);
 }
 
 .object-deletion-actions {
@@ -2137,7 +2174,7 @@ input:focus-visible {
   display: grid;
   gap: 5px;
   color: var(--color-text-muted);
-  font-size: 10px;
+  font-size: var(--dialog-label-font-size);
 }
 
 .dialog-field-control {
@@ -2209,12 +2246,12 @@ input:focus-visible {
 
 .volume-action-content strong {
   color: var(--color-text-strong);
-  font-size: 12px;
+  font-size: var(--dialog-section-font-size);
 }
 
 .volume-action-content p {
   margin: 0;
-  font-size: 11px;
+  font-size: var(--dialog-body-font-size);
 }
 
 .field-help-error,
diff --git a/apps/axkdeck/src/features/catalog/workflow.test.ts b/apps/axkdeck/src/features/catalog/workflow.test.ts
index 36b23718..dc0ea14d 100644
--- a/apps/axkdeck/src/features/catalog/workflow.test.ts
+++ b/apps/axkdeck/src/features/catalog/workflow.test.ts
@@ -44,6 +44,7 @@ function programObject(key: string, name: string): SamplerObject {
         categoryName: '',
         sfsId: 1,
         storedSizeBytes: 1,
+        sizeWithDependenciesBytes: null,
         sampleRate: 0,
         rootKey: 0,
         frameCount: 0,
diff --git a/apps/axkdeck/src/features/deletion/workflow.svelte.ts b/apps/axkdeck/src/features/deletion/workflow.svelte.ts
index 575276ba..117d8c96 100644
--- a/apps/axkdeck/src/features/deletion/workflow.svelte.ts
+++ b/apps/axkdeck/src/features/deletion/workflow.svelte.ts
@@ -6,6 +6,7 @@ import type { JobController } from '../jobs/actions';
 
 export interface ObjectDeletionRequest {
     targets: PackageExportObject[];
+    referrerObjectIds: string[];
     cleanupObjectIds: string[];
     inspection: ObjectDeletionInspection | null;
     loading: boolean;
@@ -58,6 +59,7 @@ export class DeletionWorkflow {
         const generation = ++this.objectGeneration;
         this.objectRequest = {
             targets,
+            referrerObjectIds: [],
             cleanupObjectIds: [],
             inspection: null,
             loading: true,
@@ -74,19 +76,17 @@ export class DeletionWorkflow {
         this.objectRequest = null;
     }
 
-    updateObjectSelection(objectId: string, selected: boolean): void {
+    updateObjectSelection(role: 'REFERRER' | 'DEPENDENCY', objectId: string, selected: boolean): void {
         const request = this.objectRequest;
         const inspection = request?.inspection;
         if (!request || !inspection || request.busy) return;
-        const included = new Set(
-            inspection.impacts
-                .filter((impact) => impact.role === 'DEPENDENCY' && impact.selected)
-                .map((impact) => impact.objectId),
-        );
+        const referrers = new Set(request.referrerObjectIds);
+        const cleanup = new Set(request.cleanupObjectIds);
+        const included = role === 'REFERRER' ? referrers : cleanup;
         if (selected) {
-            if (request.targets.length + included.size >= maximumPackageExportRoots) {
+            if (request.targets.length + referrers.size + cleanup.size >= maximumPackageExportRoots) {
                 this.dependencies.setStatus(
-                    `Deletion is limited to ${maximumPackageExportRoots} targets and cleanup objects`,
+                    `Deletion is limited to ${maximumPackageExportRoots} targets and related objects`,
                 );
                 return;
             }
@@ -97,45 +97,55 @@ export class DeletionWorkflow {
             while (changed) {
                 changed = false;
                 for (const impact of inspection.impacts) {
+                    const requested =
+                        (impact.role === 'REFERRER' && referrers.has(impact.objectId)) ||
+                        (impact.role === 'DEPENDENCY' && cleanup.has(impact.objectId));
                     if (
-                        included.has(impact.objectId) &&
+                        requested &&
                         impact.prerequisiteObjectIds.some((prerequisite) =>
                             inspection.impacts.some(
                                 (candidate) =>
                                     candidate.objectId === prerequisite &&
-                                    candidate.role === 'DEPENDENCY' &&
-                                    !included.has(prerequisite),
+                                    ((candidate.role === 'REFERRER' && !referrers.has(prerequisite)) ||
+                                        (candidate.role === 'DEPENDENCY' && !cleanup.has(prerequisite))),
                             ),
                         )
                     ) {
-                        included.delete(impact.objectId);
+                        if (impact.role === 'REFERRER') referrers.delete(impact.objectId);
+                        if (impact.role === 'DEPENDENCY') cleanup.delete(impact.objectId);
                         changed = true;
                     }
                 }
             }
         }
         const generation = ++this.objectGeneration;
-        this.objectRequest = { ...request, cleanupObjectIds: [...included], loading: true, error: '' };
+        this.objectRequest = {
+            ...request,
+            referrerObjectIds: [...referrers],
+            cleanupObjectIds: [...cleanup],
+            loading: true,
+            error: '',
+        };
         void this.inspectObjects(generation);
     }
 
-    updateAllObjectDependencies(selected: boolean): void {
+    updateAllObjectSelections(role: 'REFERRER' | 'DEPENDENCY', selected: boolean): void {
         const request = this.objectRequest;
         const inspection = request?.inspection;
         if (!request || !inspection || request.busy) return;
-        const cleanupCapacity = Math.max(0, maximumPackageExportRoots - request.targets.length);
-        const optional = inspection.impacts.filter(
-            (impact) => impact.role === 'DEPENDENCY' && impact.status === 'OPTIONAL',
-        );
-        if (selected && optional.length > cleanupCapacity) {
+        const otherCount = role === 'REFERRER' ? request.cleanupObjectIds.length : request.referrerObjectIds.length;
+        const capacity = Math.max(0, maximumPackageExportRoots - request.targets.length - otherCount);
+        const optional = inspection.impacts.filter((impact) => impact.role === role && impact.status === 'OPTIONAL');
+        if (selected && optional.length > capacity) {
             this.dependencies.setStatus(
-                `Deletion is limited to ${maximumPackageExportRoots} targets and cleanup objects`,
+                `Deletion is limited to ${maximumPackageExportRoots} targets and related objects`,
             );
         }
         const generation = ++this.objectGeneration;
+        const objectIds = selected ? optional.map((impact) => impact.objectId).slice(0, capacity) : [];
         this.objectRequest = {
             ...request,
-            cleanupObjectIds: selected ? optional.map((impact) => impact.objectId).slice(0, cleanupCapacity) : [],
+            ...(role === 'REFERRER' ? { referrerObjectIds: objectIds } : { cleanupObjectIds: objectIds }),
             loading: true,
             error: '',
         };
@@ -160,6 +170,7 @@ export class DeletionWorkflow {
             const finalInspection = await this.dependencies.transport.inspectObjectDeletion(
                 sessionId,
                 request.targets.map((target) => target.objectId),
+                request.referrerObjectIds,
                 request.cleanupObjectIds,
             );
             if (!finalInspection.canApply) {
@@ -171,9 +182,8 @@ export class DeletionWorkflow {
                 this.objectRequest = {
                     ...request,
                     inspection: finalInspection,
-                    cleanupObjectIds: finalInspection.impacts
-                        .filter((impact) => impact.role === 'DEPENDENCY' && impact.selected)
-                        .map((impact) => impact.objectId),
+                    referrerObjectIds: requestedImpactIds(finalInspection, 'REFERRER'),
+                    cleanupObjectIds: requestedImpactIds(finalInspection, 'DEPENDENCY'),
                     busy: false,
                     error: 'The deletion impact changed. Review the affected objects before confirming again.',
                 };
@@ -185,6 +195,7 @@ export class DeletionWorkflow {
                     this.dependencies.transport.startObjectDeletion(
                         sessionId,
                         request.targets.map((target) => target.objectId),
+                        request.referrerObjectIds,
                         request.cleanupObjectIds,
                     ),
                 (update) => {
@@ -282,7 +293,7 @@ export class DeletionWorkflow {
                 this.dependencies.setStatus('Cleanup candidates changed; review before confirming again');
                 return;
             }
-            const deletion = await this.dependencies.transport.inspectObjectDeletion(sessionId, selectedIds, []);
+            const deletion = await this.dependencies.transport.inspectObjectDeletion(sessionId, selectedIds, [], []);
             const targetImpacts = deletion.impacts.filter((impact) => impact.role === 'TARGET');
             const eligibleIds = deletion.selectedObjectIds.toSorted();
             if (
@@ -303,7 +314,7 @@ export class DeletionWorkflow {
                 return;
             }
             const completed = await this.dependencies.jobs.run(
-                () => this.dependencies.transport.startObjectDeletion(sessionId, selectedIds, []),
+                () => this.dependencies.transport.startObjectDeletion(sessionId, selectedIds, [], []),
                 (update) => {
                     if (update.progress?.label) this.dependencies.setStatus(update.progress.label);
                 },
@@ -335,6 +346,7 @@ export class DeletionWorkflow {
             const inspection = await this.dependencies.transport.inspectObjectDeletion(
                 sessionId,
                 request.targets.map((target) => target.objectId),
+                request.referrerObjectIds,
                 request.cleanupObjectIds,
             );
             if (
@@ -343,7 +355,14 @@ export class DeletionWorkflow {
                 this.dependencies.sessionId() !== sessionId
             )
                 return;
-            this.objectRequest = { ...request, inspection, loading: false, error: '' };
+            this.objectRequest = {
+                ...request,
+                referrerObjectIds: requestedImpactIds(inspection, 'REFERRER'),
+                cleanupObjectIds: requestedImpactIds(inspection, 'DEPENDENCY'),
+                inspection,
+                loading: false,
+                error: '',
+            };
         } catch (error) {
             if (
                 generation !== this.objectGeneration ||
@@ -426,10 +445,12 @@ export class DeletionWorkflow {
             nextGeneration === this.objectGeneration &&
             deletionRequestKey(this.objectRequest?.targets ?? []) === deletionRequestKey(request.targets)
         ) {
-            this.objectRequest = {
-                ...request,
-                error: `${message} The image has been refreshed; review the deletion again.`,
-            };
+            const current = this.objectRequest;
+            if (current)
+                this.objectRequest = {
+                    ...current,
+                    error: `${message} The image has been refreshed; review the deletion again.`,
+                };
         }
     }
 
@@ -460,13 +481,38 @@ function deletionRequestKey(targets: PackageExportObject[]): string {
 function deletionInspectionFingerprint(inspection: ObjectDeletionInspection): string {
     return JSON.stringify({
         selected: inspection.selectedObjectIds.toSorted(),
-        targets: inspection.impacts
-            .filter((impact) => impact.role === 'TARGET')
-            .map((impact) => [impact.objectId, impact.status, impact.reason])
-            .toSorted(([left], [right]) => left.localeCompare(right)),
+        impacts: inspection.impacts
+            .map((impact) => [
+                impact.objectId,
+                impact.role,
+                impact.status,
+                impact.requested,
+                impact.selected,
+                impact.prerequisiteObjectIds.toSorted(),
+                impact.reason,
+            ])
+            .toSorted(([left], [right]) => String(left).localeCompare(String(right))),
+        references: inspection.references
+            .map((reference) => [
+                reference.sourceObjectId,
+                reference.targetObjectId,
+                reference.type,
+                reference.quality,
+                reference.effect,
+            ])
+            .toSorted(([left], [right]) => String(left).localeCompare(String(right))),
+        blockers: inspection.blockers
+            .map((blocker) => [blocker.code, blocker.objectIds.toSorted(), blocker.message])
+            .toSorted(([left], [right]) => String(left).localeCompare(String(right))),
     });
 }
 
+function requestedImpactIds(inspection: ObjectDeletionInspection, role: 'REFERRER' | 'DEPENDENCY'): string[] {
+    return inspection.impacts
+        .filter((impact) => impact.role === role && impact.requested)
+        .map((impact) => impact.objectId);
+}
+
 function waveDataCleanupFingerprint(inspection: WaveDataOrphanInspection): string {
     return JSON.stringify(
         inspection.candidates
diff --git a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
index 78488f8d..e5d4df44 100644
--- a/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
+++ b/apps/axkdeck/src/features/dialogs/AppDialogs.svelte
@@ -40,7 +40,6 @@
     import VolumePackageExportDialog from '../../lib/components/VolumePackageExportDialog.svelte';
     import VolumeFloppyExportDialog from '../../lib/components/VolumeFloppyExportDialog.svelte';
     import WaveDataCleanupDialog from '../../lib/components/WaveDataCleanupDialog.svelte';
-    import WorkspaceManager from '../../lib/components/WorkspaceManager.svelte';
     import type { RemoteServerSettingsInput, RemoteServerSettingsView } from '../../lib/serverSettings';
     import type { DirectoryLocation, FileLocation, ImageLocation } from '../../lib/storageLocations';
     import type { CompanionSelection, ImageTransport } from '../../lib/transport';
@@ -74,9 +73,6 @@
         hardDiskDirectory: DirectoryLocation | null;
         finishHardDisk: (file: FileLocation) => void;
         cancelHardDisk: () => void;
-        workspaceManagerOpen: boolean;
-        activeWorkspaceId: string | null;
-        closeWorkspaceManager: () => void;
         connectionSettings: RemoteServerSettingsView | null;
         saveRemoteConnection: (input: RemoteServerSettingsInput) => Promise<void>;
         switchToLocalConnection: () => Promise<void>;
@@ -117,9 +113,6 @@
         hardDiskDirectory,
         finishHardDisk,
         cancelHardDisk,
-        workspaceManagerOpen,
-        activeWorkspaceId,
-        closeWorkspaceManager,
         connectionSettings,
         saveRemoteConnection,
         switchToLocalConnection,
@@ -209,7 +202,6 @@
         oncancel={cancelHardDisk}
     />
 {/if}
-<WorkspaceManager open={workspaceManagerOpen} {activeWorkspaceId} onclose={closeWorkspaceManager} />
 {#if connectionSettings}
     <ServerConnectionSettings
         settings={connectionSettings}
@@ -219,10 +211,10 @@
     />
 {/if}
 {#if mutation.volumeAction}
-    {#key `${mutation.volumeAction.action}:${mutation.volumeAction.item.id}`}
+    {#key `${mutation.volumeAction.action}:${mutation.volumeAction.items.map((item) => item.id).join(':')}`}
         <VolumeActionDialog
             action={mutation.volumeAction.action}
-            item={mutation.volumeAction.item}
+            items={mutation.volumeAction.items}
             busy={mutation.volumeActionBusy}
             phase={mutation.volumeActionPhase}
             error={mutation.volumeActionError}
@@ -478,8 +470,8 @@
         loading={deletion.objectRequest.loading}
         busy={deletion.objectRequest.busy}
         error={deletion.objectRequest.error}
-        onselectionchange={(objectId, selected) => deletion.updateObjectSelection(objectId, selected)}
-        onselectall={(selected) => deletion.updateAllObjectDependencies(selected)}
+        onselectionchange={(role, objectId, selected) => deletion.updateObjectSelection(role, objectId, selected)}
+        onselectall={(role, selected) => deletion.updateAllObjectSelections(role, selected)}
         oncancel={() => deletion.cancelObjects()}
         onconfirm={() => void deletion.submitObjects()}
     />
diff --git a/apps/axkdeck/src/features/dialogs/visibility.ts b/apps/axkdeck/src/features/dialogs/visibility.ts
index 7e470e16..2dd271e7 100644
--- a/apps/axkdeck/src/features/dialogs/visibility.ts
+++ b/apps/axkdeck/src/features/dialogs/visibility.ts
@@ -34,7 +34,6 @@ interface ExportDialogState {
 interface AppDialogState {
     pickerRequest: unknown;
     imageSession: ImageSessionDialogState;
-    workspaceManagerOpen: boolean;
     connectionSettings: unknown;
     mutation: MutationDialogState;
     packageImport: RequestDialogState;
@@ -56,7 +55,6 @@ export function hasOpenAppDialog(state: AppDialogState): boolean {
         state.pickerRequest,
         state.imageSession.companionRequest,
         state.imageSession.hardDiskDirectory,
-        state.workspaceManagerOpen,
         state.connectionSettings,
         state.mutation.volumeAction,
         state.mutation.placementRepairRequest,
diff --git a/apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts
index daa918b7..e453999e 100644
--- a/apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts
+++ b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.test.ts
@@ -1,51 +1,53 @@
 import { describe, expect, it, vi } from 'vitest';
 import { get } from 'svelte/store';
 
-import type { PackageImportWorkflow } from '../import/packageWorkflow.svelte';
+import type { PackageBatchImportWorkflow } from '../import/packageBatchWorkflow.svelte';
 import type { DiskTreeItem } from '../../lib/types';
 import { directComputerDialogVisible, DirectComputerWorkflow } from './directComputerWorkflow';
 
 const target = { kind: 'volume', id: 'volume-1', name: 'Volume 1' } as DiskTreeItem;
 
-function packageImportWorkflow(): PackageImportWorkflow {
+function packageBatchImportWorkflow(): PackageBatchImportWorkflow {
     return {
         open: vi.fn(),
         chooseLocal: vi.fn(),
-    } as unknown as PackageImportWorkflow;
+    } as unknown as PackageBatchImportWorkflow;
 }
 
 describe('DirectComputerWorkflow', () => {
     it('opens the native package picker immediately for the managed local sidecar', () => {
-        const workflow = packageImportWorkflow();
+        const workflow = packageBatchImportWorkflow();
         const coordinator = new DirectComputerWorkflow(true, 'local');
 
-        coordinator.importPackage(workflow, target);
+        coordinator.importPackages(workflow, target);
 
         expect(workflow.open).toHaveBeenCalledWith(target);
         expect(workflow.chooseLocal).toHaveBeenCalledWith(true);
-        expect(get(coordinator.pendingOperation)).toBe('package-import');
-        expect(directComputerDialogVisible(get(coordinator.pendingOperation), 'package-import', false)).toBe(false);
+        expect(get(coordinator.pendingOperation)).toBe('package-batch-import');
+        expect(directComputerDialogVisible(get(coordinator.pendingOperation), 'package-batch-import', false)).toBe(
+            false,
+        );
     });
 
     it('retains the destination chooser for a configured remote connection', () => {
-        const workflow = packageImportWorkflow();
+        const workflow = packageBatchImportWorkflow();
 
-        new DirectComputerWorkflow(true, 'remote').importPackage(workflow, target);
+        new DirectComputerWorkflow(true, 'remote').importPackages(workflow, target);
 
         expect(workflow.open).toHaveBeenCalledWith(target);
         expect(workflow.chooseLocal).not.toHaveBeenCalled();
     });
 
     it('reveals package loading and validation after a native source is selected', () => {
-        const workflow = packageImportWorkflow();
+        const workflow = packageBatchImportWorkflow();
         const coordinator = new DirectComputerWorkflow(true, 'local');
 
-        coordinator.importPackage(workflow, target);
+        coordinator.importPackages(workflow, target);
 
-        expect(directComputerDialogVisible(get(coordinator.pendingOperation), 'package-import', true)).toBe(true);
+        expect(directComputerDialogVisible(get(coordinator.pendingOperation), 'package-batch-import', true)).toBe(true);
     });
 
     it('never suppresses dialogs for configured remote connections', () => {
-        expect(directComputerDialogVisible(null, 'package-import', false)).toBe(true);
+        expect(directComputerDialogVisible(null, 'package-batch-import', false)).toBe(true);
     });
 });
diff --git a/apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts
index efe02fdd..c8555657 100644
--- a/apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts
+++ b/apps/axkdeck/src/features/file-operations/directComputerWorkflow.ts
@@ -4,7 +4,6 @@ import type { VolumePackageExportWorkflow } from '../export/volumePackageWorkflo
 import type { ExportWorkflow } from '../export/workflow.svelte';
 import type { AudioImportWorkflow } from '../import/audioWorkflow.svelte';
 import type { PackageBatchImportWorkflow } from '../import/packageBatchWorkflow.svelte';
-import type { PackageImportWorkflow } from '../import/packageWorkflow.svelte';
 import type { SequenceImportWorkflow } from '../import/sequenceWorkflow.svelte';
 import { shouldUseDirectComputerFileOperations } from '../../lib/fileOperationRouting';
 import type { ConnectionMode } from '../../lib/transport';
@@ -60,18 +59,7 @@ export class DirectComputerWorkflow {
         }
     }
 
-    importPackage(workflow: PackageImportWorkflow, target: DiskTreeItem): void {
-        if (!this.enabled) {
-            workflow.open(target);
-            return;
-        }
-        void this.run('package-import', async () => {
-            workflow.open(target);
-            await workflow.chooseLocal(true);
-        });
-    }
-
-    importVolumePackages(workflow: PackageBatchImportWorkflow, target: DiskTreeItem): void {
+    importPackages(workflow: PackageBatchImportWorkflow, target: DiskTreeItem): void {
         if (!this.enabled) {
             workflow.open(target);
             return;
diff --git a/apps/axkdeck/src/features/image-session/treeActions.test.ts b/apps/axkdeck/src/features/image-session/treeActions.test.ts
new file mode 100644
index 00000000..37dfae86
--- /dev/null
+++ b/apps/axkdeck/src/features/image-session/treeActions.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { DiskTreeItem } from '../../lib/types';
+import { createImageTreeActionHandler } from './treeActions';
+
+const volume = (id: string, partitionIndex: number): DiskTreeItem => ({
+    id,
+    name: id,
+    kind: 'volume',
+    childCount: 0,
+    partitionIndex,
+});
+
+describe('image tree action routing', () => {
+    it('deletes the complete selection when the context target is one of its volumes', () => {
+        const first = volume('first', 0);
+        const second = volume('second', 1);
+        const requestVolumeDeletion = vi.fn();
+        const handler = createImageTreeActionHandler({
+            imageSession: { volumeSelection: { items: [first, second] } },
+            mutation: { requestVolumeDeletion },
+        } as never);
+
+        handler(second, 'delete-volume');
+
+        expect(requestVolumeDeletion).toHaveBeenCalledWith([first, second]);
+    });
+
+    it('replaces the selection when deletion is requested from an unselected volume', () => {
+        const selected = volume('selected', 0);
+        const target = volume('target', 0);
+        const requestVolumeDeletion = vi.fn();
+        const handler = createImageTreeActionHandler({
+            imageSession: { volumeSelection: { items: [selected] } },
+            mutation: { requestVolumeDeletion },
+        } as never);
+
+        handler(target, 'delete-volume');
+
+        expect(requestVolumeDeletion).toHaveBeenCalledWith([target]);
+    });
+});
diff --git a/apps/axkdeck/src/features/image-session/treeActions.ts b/apps/axkdeck/src/features/image-session/treeActions.ts
new file mode 100644
index 00000000..236cd672
--- /dev/null
+++ b/apps/axkdeck/src/features/image-session/treeActions.ts
@@ -0,0 +1,117 @@
+import type { ImageTransport } from '../../lib/transport';
+import type { DiskTreeItem, ImageTreeAction, PackageExportSelection } from '../../lib/types';
+import { openAllocationInspector } from '../../lib/allocationInspector';
+import { userFacingMessage } from '../../lib/userFacingMessage';
+import type { DirectComputerWorkflow } from '../file-operations/directComputerWorkflow';
+import type { ExportWorkflow } from '../export/workflow.svelte';
+import type { MediaExportWorkflow } from '../export/mediaWorkflow.svelte';
+import type { VolumeFloppyExportWorkflow } from '../export/volumeFloppyWorkflow.svelte';
+import type { VolumePackageExportWorkflow } from '../export/volumePackageWorkflow.svelte';
+import type { PackageBatchImportWorkflow } from '../import/packageBatchWorkflow.svelte';
+import type { MutationWorkflow } from '../mutation/workflow.svelte';
+import type { ImageSessionWorkflow } from './workflow.svelte';
+
+interface ImageTreeActionDependencies {
+    transport: ImageTransport;
+    imageSession: ImageSessionWorkflow;
+    mutation: MutationWorkflow;
+    directComputer: DirectComputerWorkflow;
+    packageBatchImport: PackageBatchImportWorkflow;
+    exports: ExportWorkflow;
+    volumePackages: VolumePackageExportWorkflow;
+    volumeFloppies: VolumeFloppyExportWorkflow;
+    mediaExports: MediaExportWorkflow;
+    isDesktop: boolean;
+    exportAudio: (items: PackageExportSelection[]) => Promise<void>;
+}
+
+export function createImageTreeActionHandler(dependencies: ImageTreeActionDependencies) {
+    const { imageSession } = dependencies;
+    return (item: DiskTreeItem, action: ImageTreeAction): void => {
+        if (action === 'delete-volume' && item.kind === 'volume') {
+            const selected = imageSession.volumeSelection.items;
+            dependencies.mutation.requestVolumeDeletion(
+                selected.some((candidate) => candidate.id === item.id) ? selected : [item],
+            );
+            return;
+        }
+        if (item.partitionIndex === undefined) return;
+        if (action === 'inspect-allocation') {
+            const sessionId = imageSession.sessionId;
+            if (
+                !dependencies.isDesktop ||
+                sessionId === null ||
+                !imageSession.allocationInspectionAvailable ||
+                item.kind !== 'partition'
+            )
+                return;
+            imageSession.selectSource(item);
+            void dependencies.transport
+                .allocationMapReference(sessionId)
+                .then((reference) =>
+                    openAllocationInspector({
+                        ...reference,
+                        partitionIndex: item.partitionIndex!,
+                        partitionName: item.name,
+                    }),
+                )
+                .catch((error) => imageSession.setStatus(userFacingMessage(error)));
+            return;
+        }
+        if (action === 'import-packages') {
+            if (!imageSession.packageImportAvailable || (item.kind !== 'partition' && item.kind !== 'volume')) return;
+            imageSession.selectSource(item);
+            dependencies.directComputer.importPackages(dependencies.packageBatchImport, item);
+            return;
+        }
+        if (action === 'export-package') {
+            if (!imageSession.packageExportAvailable || item.kind !== 'volume') return;
+            imageSession.selectSource(item);
+            dependencies.directComputer.exportPackage(dependencies.exports, [
+                {
+                    kind: 'VOLUME',
+                    contentId: item.id,
+                    partitionIndex: item.partitionIndex,
+                    volumeName: item.name,
+                    name: item.name,
+                    typeLabel: 'Volume',
+                },
+            ]);
+            return;
+        }
+        if (action === 'export-volume-packages') {
+            if (!imageSession.volumePackageExportAvailable || item.kind !== 'partition') return;
+            imageSession.selectSource(item);
+            void dependencies.directComputer.exportVolumePackages(dependencies.volumePackages, item);
+            return;
+        }
+        if (action === 'export-volume-floppies') {
+            if (!imageSession.volumeFloppyExportAvailable || item.kind !== 'partition') return;
+            imageSession.selectSource(item);
+            void dependencies.directComputer.exportVolumeFloppies(dependencies.volumeFloppies, item);
+            return;
+        }
+        if (action === 'export-sfz') {
+            if (!imageSession.audioExportAvailable || item.kind !== 'volume') return;
+            imageSession.selectSource(item);
+            void dependencies.exportAudio([
+                {
+                    kind: 'VOLUME',
+                    contentId: item.id,
+                    partitionIndex: item.partitionIndex,
+                    volumeName: item.name,
+                    name: item.name,
+                    typeLabel: 'Volume',
+                },
+            ]);
+            return;
+        }
+        if (action === 'export-cdrom' || action === 'export-floppy') {
+            if (!imageSession.mediaConversionAvailable) return;
+            imageSession.selectSource(item);
+            void dependencies.directComputer.exportMedia(dependencies.mediaExports, item);
+            return;
+        }
+        if (dependencies.mutation.requestVolumeAction(item, action)) imageSession.selectSource(item);
+    };
+}
diff --git a/apps/axkdeck/src/features/image-session/workflow.svelte.ts b/apps/axkdeck/src/features/image-session/workflow.svelte.ts
index 84316938..178044b0 100644
--- a/apps/axkdeck/src/features/image-session/workflow.svelte.ts
+++ b/apps/axkdeck/src/features/image-session/workflow.svelte.ts
@@ -8,6 +8,8 @@ import type {
     OpenedImage,
 } from '../../lib/transport';
 import type { DiskTreeItem } from '../../lib/types';
+import type { ObjectSelectionMode } from '../../lib/objectSelection';
+import { emptyVolumeSelection, updateVolumeSelection, type VolumeSelectionState } from '../../lib/volumeSelection';
 import { AxklibApiError } from '../../lib/httpErrors';
 import { userFacingMessage } from '../../lib/userFacingMessage';
 import type { AuditionWorkflow } from '../audition/workflow.svelte';
@@ -55,6 +57,7 @@ interface SessionCollaborators {
 
 export class ImageSessionWorkflow {
     sourceItems = $state<DiskTreeItem[]>([]);
+    volumeSelection = $state<VolumeSelectionState>(emptyVolumeSelection());
     selectedSource = $state<DiskTreeItem>({
         id: 'none',
         name: 'No image',
@@ -145,6 +148,45 @@ export class ImageSessionWorkflow {
     }
 
     selectSource(item: DiskTreeItem): void {
+        this.selectTreeSource(item, 'replace', collectVolumes(this.sourceItems));
+    }
+
+    selectTreeSource(item: DiskTreeItem, mode: ObjectSelectionMode, visibleVolumes: readonly DiskTreeItem[]): void {
+        const update = updateVolumeSelection(this.volumeSelection, visibleVolumes, item, mode);
+        this.volumeSelection = update.selection;
+        this.activateSource(update.active);
+    }
+
+    selectSourceForContext(item: DiskTreeItem, visibleVolumes: readonly DiskTreeItem[]): void {
+        if (item.kind === 'volume' && this.volumeSelection.items.some((candidate) => candidate.id === item.id)) {
+            this.activateSource(item);
+            return;
+        }
+        this.selectTreeSource(item, 'replace', visibleVolumes);
+    }
+
+    importDestinationSource(): DiskTreeItem {
+        const selected = this.volumeSelection.items;
+        if (selected.length === 1) return selected[0]!;
+        if (selected.length > 1) {
+            const partitionIndex = selected[0]?.partitionIndex;
+            if (partitionIndex !== undefined && selected.every((item) => item.partitionIndex === partitionIndex)) {
+                return (
+                    findPartition(this.sourceItems, partitionIndex) ?? {
+                        id: `selected-partition-${partitionIndex}`,
+                        name: `Partition ${partitionIndex + 1}`,
+                        kind: 'partition',
+                        childCount: 0,
+                        partitionIndex,
+                    }
+                );
+            }
+            return noImageSource();
+        }
+        return this.selectedSource.kind === 'volume' ? noImageSource() : this.selectedSource;
+    }
+
+    private activateSource(item: DiskTreeItem): void {
         const { catalog } = this.requireCollaborators();
         this.selectedSource = item;
         if (item.kind !== 'volume') {
@@ -307,7 +349,8 @@ export class ImageSessionWorkflow {
         try {
             await this.closeOpenSession();
             this.sourceItems = [];
-            this.selectedSource = { id: 'none', name: 'No image', kind: 'disk', childCount: 0 };
+            this.volumeSelection = emptyVolumeSelection();
+            this.selectedSource = noImageSource();
             this.requireCollaborators().catalog.clear();
             this.status = 'Ready';
         } catch (error) {
@@ -401,6 +444,10 @@ export class ImageSessionWorkflow {
             ? findSourceItem(opened.tree, preferred.partitionIndex, preferred.volumeName)
             : null;
         this.selectedSource = preferredItem ?? opened.initialVolume ?? opened.tree[0] ?? this.selectedSource;
+        this.volumeSelection =
+            this.selectedSource.kind === 'volume'
+                ? { items: [this.selectedSource], anchorId: this.selectedSource.id }
+                : emptyVolumeSelection();
         if (this.selectedSource.kind === 'volume')
             await catalog.loadVolume(this.selectedSource.id, this.selectedSource.partitionIndex ?? null);
         else catalog.clear();
@@ -499,6 +546,28 @@ function sameImageSource(left: ImageLocation, right: ImageLocation): boolean {
     );
 }
 
+function noImageSource(): DiskTreeItem {
+    return { id: 'none', name: 'No image', kind: 'disk', childCount: 0 };
+}
+
+function collectVolumes(items: readonly DiskTreeItem[]): DiskTreeItem[] {
+    const result: DiskTreeItem[] = [];
+    for (const item of items) {
+        if (item.kind === 'volume') result.push(item);
+        result.push(...collectVolumes(item.children ?? []));
+    }
+    return result;
+}
+
+function findPartition(items: readonly DiskTreeItem[], partitionIndex: number): DiskTreeItem | null {
+    for (const item of items) {
+        if (item.kind === 'partition' && item.partitionIndex === partitionIndex) return item;
+        const nested = findPartition(item.children ?? [], partitionIndex);
+        if (nested) return nested;
+    }
+    return null;
+}
+
 function findSourceItem(items: DiskTreeItem[], partitionIndex: number, volumeName?: string): DiskTreeItem | null {
     for (const item of items) {
         if (
diff --git a/apps/axkdeck/src/features/image-session/workflow.test.ts b/apps/axkdeck/src/features/image-session/workflow.test.ts
index 5b52f98c..05add244 100644
--- a/apps/axkdeck/src/features/image-session/workflow.test.ts
+++ b/apps/axkdeck/src/features/image-session/workflow.test.ts
@@ -92,3 +92,62 @@ describe('ImageSessionWorkflow lease maintenance', () => {
         await workflow.dispose();
     });
 });
+
+describe('ImageSessionWorkflow volume selection', () => {
+    it('uses one volume as an import target and only a shared partition for a multi-selection', async () => {
+        const transport = { closeImage: vi.fn(async () => undefined) } as unknown as ImageTransport;
+        const workflow = new ImageSessionWorkflow(transport, {} as PickerController);
+        workflow.connect({
+            catalog: { activeVolumeId: '', loadVolume: vi.fn(async () => undefined), clear: vi.fn() },
+        } as never);
+        const volumeA = {
+            id: 'volume-a',
+            name: 'A',
+            kind: 'volume' as const,
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const volumeB = {
+            id: 'volume-b',
+            name: 'B',
+            kind: 'volume' as const,
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const volumeC = {
+            id: 'volume-c',
+            name: 'C',
+            kind: 'volume' as const,
+            childCount: 0,
+            partitionIndex: 1,
+        };
+        const partitionA = {
+            id: 'partition-a',
+            name: 'PARTITION 1',
+            kind: 'partition' as const,
+            childCount: 2,
+            partitionIndex: 0,
+            children: [volumeA, volumeB],
+        };
+        const partitionB = {
+            id: 'partition-b',
+            name: 'PARTITION 2',
+            kind: 'partition' as const,
+            childCount: 1,
+            partitionIndex: 1,
+            children: [volumeC],
+        };
+        workflow.sourceItems = [partitionA, partitionB];
+        const visible = [volumeA, volumeB, volumeC];
+
+        workflow.selectTreeSource(volumeA, 'replace', visible);
+        expect(workflow.importDestinationSource()).toMatchObject({ id: 'volume-a', kind: 'volume' });
+
+        workflow.selectTreeSource(volumeB, 'toggle', visible);
+        expect(workflow.importDestinationSource()).toMatchObject({ id: 'partition-a', kind: 'partition' });
+
+        workflow.selectTreeSource(volumeC, 'toggle', visible);
+        expect(workflow.importDestinationSource()).toMatchObject({ id: 'none', kind: 'disk' });
+        await workflow.dispose();
+    });
+});
diff --git a/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts b/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts
index 834fdf08..132c06ac 100644
--- a/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/audioWorkflow.svelte.ts
@@ -199,9 +199,7 @@ export class AudioImportWorkflow {
         request.destinationMode = mode;
         request.destinationVolumeName = '';
         request.destinationPartitionIndex =
-            mode === 'create'
-                ? (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null)
-                : null;
+            request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null;
     }
 
     async setExistingVolume(partitionIndex: number | null, volumeName: string): Promise<void> {
@@ -221,7 +219,9 @@ export class AudioImportWorkflow {
     }
 
     setDestinationPartition(partitionIndex: number): void {
-        if (this.request) this.request.destinationPartitionIndex = partitionIndex;
+        if (!this.request) return;
+        this.request.destinationPartitionIndex = partitionIndex;
+        if (this.request.destinationMode === 'existing') this.request.destinationVolumeName = '';
     }
 
     setDestinationVolumeName(volumeName: string): void {
@@ -233,10 +233,11 @@ export class AudioImportWorkflow {
         selected: DiskTreeItem | null,
     ): AudioImportRequest {
         const initial = selected ? initialImportDestination(selected) : null;
+        const firstPartition = collectImportDestinations(this.dependencies.sourceItems()).partitions[0];
         return {
             files,
             destinationMode: initial?.mode ?? 'existing',
-            destinationPartitionIndex: initial?.partitionIndex ?? null,
+            destinationPartitionIndex: initial?.partitionIndex ?? firstPartition?.partitionIndex ?? null,
             destinationVolumeName: initial?.volumeName ?? '',
         };
     }
diff --git a/apps/axkdeck/src/features/import/audioWorkflow.test.ts b/apps/axkdeck/src/features/import/audioWorkflow.test.ts
new file mode 100644
index 00000000..fe86c601
--- /dev/null
+++ b/apps/axkdeck/src/features/import/audioWorkflow.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from 'vitest';
+import { serverFileLocation } from '../../lib/storageLocations';
+import type { ImageTransport } from '../../lib/transport';
+import type { DiskTreeItem } from '../../lib/types';
+import { PickerController } from '../dialogs/picker';
+import type { JobController } from '../jobs/actions';
+import { AudioImportWorkflow } from './audioWorkflow.svelte';
+
+describe('AudioImportWorkflow', () => {
+    it('clears an existing volume without loading another volume when its partition changes', () => {
+        const firstVolume: DiskTreeItem = {
+            id: 'volume-0',
+            name: 'First',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const secondVolume: DiskTreeItem = {
+            id: 'volume-1',
+            name: 'Second',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 1,
+        };
+        const loadVolume = vi.fn();
+        const workflow = new AudioImportWorkflow({
+            transport: {} as ImageTransport,
+            jobs: {} as JobController,
+            picker: new PickerController(() => undefined),
+            sessionId: () => 17,
+            imageLocation: () => serverFileLocation({ rootId: 'root', relativePath: 'image.hds' }),
+            imageFormat: () => 'sfs',
+            mutationsAvailable: () => true,
+            selectedSource: () => firstVolume,
+            setSelectedSource: vi.fn(),
+            sourceItems: () => [firstVolume, secondVolume],
+            activeVolumeId: () => firstVolume.id,
+            sampleBanks: () => [],
+            samples: () => [],
+            loadVolume,
+            refreshSession: vi.fn(),
+            invalidateSession: vi.fn(),
+            selectWorkspace: vi.fn(),
+            selectSampleBank: vi.fn(),
+            selectSample: vi.fn(),
+            setStatus: vi.fn(),
+            reportTiming: vi.fn(),
+        });
+
+        workflow.chooseFiles();
+        workflow.setDestinationPartition(1);
+
+        expect(workflow.request).toMatchObject({
+            destinationMode: 'existing',
+            destinationPartitionIndex: 1,
+            destinationVolumeName: '',
+        });
+        expect(loadVolume).not.toHaveBeenCalled();
+    });
+});
diff --git a/apps/axkdeck/src/features/import/packageBatchPlanning.ts b/apps/axkdeck/src/features/import/packageBatchPlanning.ts
index e99ae752..8875f119 100644
--- a/apps/axkdeck/src/features/import/packageBatchPlanning.ts
+++ b/apps/axkdeck/src/features/import/packageBatchPlanning.ts
@@ -64,15 +64,13 @@ export function normalizedBatchDestination(
             volume.volumeName === request.destinationVolumeName,
     );
     const mode = selectedVolume ? 'existing' : request.item?.kind === 'partition' ? 'create' : 'existing';
-    const firstVolume = selectedVolume ?? destinations.volumes[0];
+    const partitionIndex = request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null;
     return {
         destinationStrategy: 'shared',
         destinationMode: mode,
-        destinationPartitionIndex:
-            mode === 'existing'
-                ? (firstVolume?.partitionIndex ?? null)
-                : (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null),
-        destinationVolumeName: mode === 'existing' ? (firstVolume?.volumeName ?? '') : suggestedSharedVolumeName(items),
+        destinationPartitionIndex: selectedVolume?.partitionIndex ?? partitionIndex,
+        destinationVolumeName:
+            mode === 'existing' ? (selectedVolume?.volumeName ?? '') : suggestedSharedVolumeName(items),
     };
 }
 
diff --git a/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts b/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
index 6e34f07c..e7855669 100644
--- a/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/packageBatchWorkflow.svelte.ts
@@ -8,7 +8,6 @@ import { reportError } from '../../lib/diagnostics';
 import { userFacingMessage } from '../../lib/userFacingMessage';
 import {
     collectImportDestinations,
-    importDestination,
     initialImportDestination,
     type ImportDestinationMode,
     type ImportPartitionOption,
@@ -64,7 +63,7 @@ export class PackageBatchImportWorkflow {
         this.plannedItemIds = [];
         const destination = initialImportDestination(item) ?? {
             mode: 'existing' as const,
-            partitionIndex: null,
+            partitionIndex: this.destinations().partitions[0]?.partitionIndex ?? null,
             volumeName: '',
         };
         this.request = {
@@ -93,58 +92,48 @@ export class PackageBatchImportWorkflow {
         const request = this.request;
         if (!request || request.status === 'applying' || request.destinationStrategy === strategy) return;
         if (strategy === 'separate' && !separateVolumesAvailable(request.items.filter((item) => item.selected))) return;
-        this.updateDestination({ destinationStrategy: strategy }, true);
+        this.updateDestination({ destinationStrategy: strategy });
     }
 
     setDestinationMode(mode: ImportDestinationMode): void {
         const request = this.request;
         if (!request || request.status === 'applying' || request.destinationMode === mode) return;
         const destinations = this.destinations();
-        const currentVolume = destinations.volumes.find(
-            (option) =>
-                option.partitionIndex === request.destinationPartitionIndex &&
-                option.volumeName === request.destinationVolumeName,
-        );
-        const existingVolume = currentVolume ?? destinations.volumes[0];
-        this.updateDestination(
-            {
-                destinationStrategy: 'shared',
-                destinationMode: mode,
-                destinationPartitionIndex:
-                    mode === 'existing'
-                        ? (existingVolume?.partitionIndex ?? null)
-                        : (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null),
-                destinationVolumeName:
-                    mode === 'existing' ? (existingVolume?.volumeName ?? '') : suggestedSharedVolumeName(request.items),
-            },
-            true,
-        );
+        this.updateDestination({
+            destinationStrategy: 'shared',
+            destinationMode: mode,
+            destinationPartitionIndex:
+                request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null,
+            destinationVolumeName: mode === 'existing' ? '' : suggestedSharedVolumeName(request.items),
+        });
     }
 
     setExistingVolume(partitionIndex: number | null, volumeName: string): void {
         const request = this.request;
         if (!request || request.status === 'applying') return;
-        this.updateDestination(
-            {
-                destinationStrategy: 'shared',
-                destinationMode: 'existing',
-                destinationPartitionIndex: partitionIndex,
-                destinationVolumeName: volumeName,
-            },
-            partitionIndex !== null,
-        );
+        this.updateDestination({
+            destinationStrategy: 'shared',
+            destinationMode: 'existing',
+            destinationPartitionIndex: partitionIndex,
+            destinationVolumeName: volumeName,
+        });
     }
 
     setDestinationPartition(partitionIndex: number): void {
         const request = this.request;
         if (!request || request.status === 'applying') return;
-        this.updateDestination({ destinationPartitionIndex: partitionIndex }, true);
+        this.updateDestination({
+            destinationPartitionIndex: partitionIndex,
+            ...(request.destinationStrategy === 'shared' && request.destinationMode === 'existing'
+                ? { destinationVolumeName: '' }
+                : {}),
+        });
     }
 
     setDestinationVolumeName(volumeName: string): void {
         const request = this.request;
         if (!request || request.status === 'applying') return;
-        this.updateDestination({ destinationVolumeName: volumeName.slice(0, 16) }, false);
+        this.updateDestination({ destinationVolumeName: volumeName.slice(0, 16) });
     }
 
     renameVolume(itemId: string, name: string): void {
@@ -251,7 +240,6 @@ export class PackageBatchImportWorkflow {
             opaqueSequenceActions: { ...this.request.opaqueSequenceActions, [key]: action },
             hasUnvalidatedChanges: true,
         };
-        void this.replan();
     }
 
     destinationName(itemId: string): string {
@@ -475,10 +463,8 @@ export class PackageBatchImportWorkflow {
         try {
             await this.dependencies.refreshSession({ partitionIndex: request.destinationPartitionIndex! });
             if (generation !== this.generation || !this.request) return;
-            await this.plan(generation);
-            if (generation === this.generation && this.request?.status === 'ready' && this.request.plan) {
-                this.dependencies.setStatus('Image changed; import conflicts checked again');
-            }
+            this.request = { ...this.request, status: 'ready' };
+            this.dependencies.setStatus('Image changed; check import conflicts again');
         } catch (error) {
             if (generation !== this.generation || !this.request) return;
             const message = userFacingMessage(error);
@@ -555,20 +541,24 @@ export class PackageBatchImportWorkflow {
                 this.request = { ...this.request, items: [...items], completedFiles: index + 1 };
             }
             const destination = normalizedBatchDestination(this.request, items, this.destinations());
-            this.request = { ...this.request, ...destination, status: 'planning' };
-            await this.plan(generation);
+            this.request = {
+                ...this.request,
+                ...destination,
+                status: 'ready',
+                hasUnvalidatedChanges: true,
+            };
         } catch (error) {
             await Promise.all(sources.map((item) => this.releaseUpload(item.upload)));
             if (generation !== this.generation || !this.request) return;
+            reportError('Inspect package batch failed', error);
             this.request = { ...this.request, items: [], status: 'choosing', error: userFacingMessage(error) };
         }
     }
 
     private async plan(generation: number, replacePlanToken?: string): Promise<void> {
-        const automaticPlanToken = await this.planOnce(generation, replacePlanToken, true);
-        if (!automaticPlanToken) return;
         try {
-            await this.planOnce(generation, automaticPlanToken, false);
+            const automaticPlanToken = await this.planOnce(generation, replacePlanToken, true);
+            if (automaticPlanToken) await this.planOnce(generation, automaticPlanToken, false);
         } catch (error) {
             if (generation === this.generation && this.request) {
                 this.request = { ...this.request, status: 'ready', error: userFacingMessage(error) };
@@ -591,47 +581,40 @@ export class PackageBatchImportWorkflow {
             }
             return null;
         }
+        if (generation !== this.generation) return null;
         this.request = { ...request, status: 'planning', error: '' };
-        try {
-            const plan = await this.dependencies.transport.planImagePackageImport(
-                sessionId,
-                selectedItems.map((item) => item.source),
-                arguments_.destination,
-                arguments_.renames,
-                arguments_.programSlotAssignments,
-                replacePlanToken,
-                arguments_.opaqueSequenceDecisions,
-            );
-            if (generation !== this.generation || !this.request) {
-                await this.releasePlan(plan);
-                return null;
-            }
-            const merged = mergeBatchPlanSuggestions(request, selectedItems, plan);
-            const checkSuggestedProgramSlots =
-                allowAutomaticProgramSlotCheck &&
-                merged.suggestedSlotsAdded &&
-                plan.programSlotPlacements.some(
-                    (placement) =>
-                        !placement.applied && placement.mode !== 'UNAVAILABLE' && placement.mappings.length > 0,
-                );
-            this.request = {
-                ...this.request,
-                plan,
-                volumeNames: merged.volumeNames,
-                renames: merged.renames,
-                programSlots: merged.programSlots,
-                hasUnvalidatedChanges: merged.suggestedSlotsAdded,
-                status: checkSuggestedProgramSlots ? 'planning' : 'ready',
-                error: '',
-            };
-            this.plannedItemIds = selectedItems.map((item) => item.id);
-            return checkSuggestedProgramSlots ? plan.planToken : null;
-        } catch (error) {
-            if (generation === this.generation && this.request) {
-                this.request = { ...this.request, status: 'ready', error: userFacingMessage(error) };
-            }
+        const plan = await this.dependencies.transport.planImagePackageImport(
+            sessionId,
+            selectedItems.map((item) => item.source),
+            arguments_.destination,
+            arguments_.renames,
+            arguments_.programSlotAssignments,
+            replacePlanToken,
+            arguments_.opaqueSequenceDecisions,
+        );
+        if (generation !== this.generation || !this.request) {
+            await this.releasePlan(plan);
             return null;
         }
+        const merged = mergeBatchPlanSuggestions(request, selectedItems, plan);
+        const checkSuggestedProgramSlots =
+            allowAutomaticProgramSlotCheck &&
+            merged.suggestedSlotsAdded &&
+            plan.programSlotPlacements.some(
+                (placement) => !placement.applied && placement.mode !== 'UNAVAILABLE' && placement.mappings.length > 0,
+            );
+        this.request = {
+            ...this.request,
+            plan,
+            volumeNames: merged.volumeNames,
+            renames: merged.renames,
+            programSlots: merged.programSlots,
+            hasUnvalidatedChanges: merged.suggestedSlotsAdded,
+            status: checkSuggestedProgramSlots ? 'planning' : 'ready',
+            error: '',
+        };
+        this.plannedItemIds = selectedItems.map((item) => item.id);
+        return checkSuggestedProgramSlots ? plan.planToken : null;
     }
 
     private updateDestination(
@@ -641,7 +624,6 @@ export class PackageBatchImportWorkflow {
                 'destinationStrategy' | 'destinationMode' | 'destinationPartitionIndex' | 'destinationVolumeName'
             >
         >,
-        automaticallyPlan: boolean,
     ): void {
         const request = this.request;
         if (!request || request.status === 'applying') return;
@@ -656,23 +638,10 @@ export class PackageBatchImportWorkflow {
             status: request.items.length > 0 ? ('ready' as const) : request.status,
             error: '',
         };
-        const destinationReady =
-            next.destinationStrategy === 'separate'
-                ? next.destinationPartitionIndex !== null &&
-                  separateVolumesAvailable(next.items.filter((item) => item.selected))
-                : importDestination(
-                      next.destinationMode,
-                      next.destinationPartitionIndex,
-                      next.destinationVolumeName,
-                  ) !== null;
-        const shouldPlan = automaticallyPlan && next.items.some((item) => item.selected) && destinationReady;
-        const generation = ++this.generation;
-        this.request = { ...next, status: shouldPlan ? 'planning' : next.status };
-        void (async () => {
-            await this.releasePlan(previousPlan);
-            if (!shouldPlan || generation !== this.generation || !this.request) return;
-            await this.plan(generation);
-        })();
+        ++this.generation;
+        this.plannedItemIds = [];
+        this.request = next;
+        void this.releasePlan(previousPlan);
     }
 
     private destinations() {
diff --git a/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts b/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts
index af977c0e..6d6e37aa 100644
--- a/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/packageBatchWorkflow.test.ts
@@ -78,6 +78,270 @@ function plan(names: string[], token: string): ImageSessionPackageImportPlan {
 }
 
 describe('PackageBatchImportWorkflow', () => {
+    it('clears a shared existing volume without planning when its partition changes', () => {
+        const firstVolume: DiskTreeItem = {
+            id: 'volume-0',
+            name: 'First',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const secondVolume: DiskTreeItem = {
+            id: 'volume-1',
+            name: 'Second',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 1,
+        };
+        const planImagePackageImport = vi.fn();
+        const workflow = new PackageBatchImportWorkflow({
+            transport: { planImagePackageImport } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker: new PickerController(() => undefined),
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn(),
+            refreshSession: vi.fn(),
+            setStatus: vi.fn(),
+            sourceItems: () => [firstVolume, secondVolume],
+        });
+
+        workflow.open(firstVolume);
+        workflow.setDestinationPartition(1);
+
+        expect(workflow.request).toMatchObject({
+            destinationStrategy: 'shared',
+            destinationMode: 'existing',
+            destinationPartitionIndex: 1,
+            destinationVolumeName: '',
+            plan: null,
+        });
+        expect(planImagePackageImport).not.toHaveBeenCalled();
+    });
+
+    it('waits for an explicit conflict check after loading packages', async () => {
+        const sources = [serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkvol' }, 'one.axkvol')];
+        const planImagePackageImport = vi.fn().mockResolvedValue(plan(['One'], 'explicit-plan'));
+        const picker = new PickerController(() => undefined);
+        const workflow = new PackageBatchImportWorkflow({
+            transport: {
+                inspectPackage: vi.fn().mockResolvedValue(inspection('package-0', 'One', 1)),
+                planImagePackageImport,
+                releaseImagePackageImportPlan: vi.fn().mockResolvedValue(undefined),
+            } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker,
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn().mockResolvedValue(undefined),
+            refreshSession: vi.fn().mockResolvedValue(undefined),
+            setStatus: vi.fn(),
+        });
+        const partition: DiskTreeItem = {
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 0,
+            partitionIndex: 0,
+        };
+
+        workflow.open(partition);
+        const choosing = workflow.chooseWorkspace();
+        picker.finish(sources);
+        await choosing;
+
+        expect(planImagePackageImport).not.toHaveBeenCalled();
+        expect(workflow.request).toMatchObject({
+            plan: null,
+            status: 'ready',
+            hasUnvalidatedChanges: true,
+        });
+
+        await workflow.replan();
+
+        expect(planImagePackageImport).toHaveBeenCalledTimes(1);
+        expect(workflow.request?.plan?.planToken).toBe('explicit-plan');
+
+        const itemId = workflow.request!.items[0].id;
+        workflow.opaqueSequenceAction(itemId, 'sequence-1', 'SKIP');
+        workflow.setDestinationPartition(1);
+        await Promise.resolve();
+
+        expect(planImagePackageImport).toHaveBeenCalledTimes(1);
+        expect(workflow.request).toMatchObject({
+            plan: null,
+            status: 'ready',
+            hasUnvalidatedChanges: true,
+        });
+    });
+
+    it('checks suggested Program slots once within an explicit batch conflict check', async () => {
+        const sources = [
+            serverFileLocation({ rootId: 'workspace', relativePath: 'pads-1.axkvol' }, 'pads-1.axkvol'),
+            serverFileLocation({ rootId: 'workspace', relativePath: 'pads-2.axkvol' }, 'pads-2.axkvol'),
+            serverFileLocation({ rootId: 'workspace', relativePath: 'pads-3.axkvol' }, 'pads-3.axkvol'),
+        ];
+        const suggestedPlan = plan(['Pads 1', 'Pads 2', 'Pads 3'], 'suggested-plan');
+        suggestedPlan.valid = false;
+        suggestedPlan.programSlotPlacements = [
+            {
+                placementId: 'placement-1',
+                partitionIndex: 0,
+                volumeName: 'Target',
+                mode: 'CONTIGUOUS',
+                applied: false,
+                suggestedStartSlot: 21,
+                requiredSlotCount: 3,
+                availableSlotCount: 108,
+                occupiedRanges: [{ first: 1, last: 20 }],
+                sourceRanges: [{ first: 1, last: 3 }],
+                destinationRanges: [{ first: 21, last: 23 }],
+                mappings: sources.map((_, packageIndex) => ({
+                    packageIndex,
+                    nodeId: `package-${packageIndex}-0`,
+                    sourceSlot: packageIndex + 1,
+                    destinationSlot: packageIndex + 21,
+                    requiresUserAction: false,
+                })),
+            },
+        ];
+        const checkedPlan = plan(['Pads 1', 'Pads 2', 'Pads 3'], 'checked-plan');
+        checkedPlan.programSlotPlacements = suggestedPlan.programSlotPlacements.map((placement) => ({
+            ...placement,
+            applied: true,
+        }));
+        const planImagePackageImport = vi.fn().mockResolvedValueOnce(suggestedPlan).mockResolvedValueOnce(checkedPlan);
+        const picker = new PickerController(() => undefined);
+        const volume: DiskTreeItem = {
+            id: 'volume-0',
+            name: 'Target',
+            kind: 'volume',
+            childCount: 20,
+            partitionIndex: 0,
+        };
+        const workflow = new PackageBatchImportWorkflow({
+            transport: {
+                inspectPackage: vi
+                    .fn()
+                    .mockResolvedValueOnce(inspection('package-0', 'Pads 1', 1))
+                    .mockResolvedValueOnce(inspection('package-1', 'Pads 2', 1))
+                    .mockResolvedValueOnce(inspection('package-2', 'Pads 3', 1)),
+                planImagePackageImport,
+                releaseImagePackageImportPlan: vi.fn().mockResolvedValue(undefined),
+            } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker,
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn().mockResolvedValue(undefined),
+            refreshSession: vi.fn().mockResolvedValue(undefined),
+            setStatus: vi.fn(),
+            sourceItems: () => [volume],
+        });
+
+        workflow.open(volume);
+        const choosing = workflow.chooseWorkspace();
+        picker.finish(sources);
+        await choosing;
+        await workflow.replan();
+
+        expect(planImagePackageImport).toHaveBeenCalledTimes(2);
+        expect(planImagePackageImport).toHaveBeenNthCalledWith(
+            2,
+            17,
+            sources,
+            { kind: 'EXISTING_VOLUME', partitionIndex: 0, volumeName: 'Target' },
+            [],
+            sources.map((_, packageIndex) => ({
+                packageIndex,
+                nodeId: `package-${packageIndex}-0`,
+                destinationSlot: packageIndex + 21,
+            })),
+            'suggested-plan',
+            [],
+        );
+        expect(workflow.request).toMatchObject({
+            plan: { planToken: 'checked-plan', valid: true },
+            status: 'ready',
+            hasUnvalidatedChanges: false,
+        });
+        expect(Object.values(workflow.request!.programSlots)).toEqual([21, 22, 23]);
+    });
+
+    it('limits automatic batch Program slot checks to one replacement plan', async () => {
+        const source = serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkvol' }, 'one.axkvol');
+        const firstPlan = plan(['One'], 'suggested-plan-1');
+        firstPlan.valid = false;
+        firstPlan.programSlotPlacements = [
+            {
+                placementId: 'placement-1',
+                partitionIndex: 0,
+                volumeName: 'One',
+                mode: 'CONTIGUOUS',
+                applied: false,
+                suggestedStartSlot: 5,
+                requiredSlotCount: 1,
+                availableSlotCount: 124,
+                occupiedRanges: [{ first: 1, last: 4 }],
+                sourceRanges: [{ first: 1, last: 1 }],
+                destinationRanges: [{ first: 5, last: 5 }],
+                mappings: [
+                    {
+                        packageIndex: 0,
+                        nodeId: 'package-0-0',
+                        sourceSlot: 1,
+                        destinationSlot: 5,
+                        requiresUserAction: false,
+                    },
+                ],
+            },
+        ];
+        const secondPlan = {
+            ...firstPlan,
+            planToken: 'suggested-plan-2',
+            planId: 'suggested-plan-2-id',
+        };
+        const planImagePackageImport = vi.fn().mockResolvedValueOnce(firstPlan).mockResolvedValueOnce(secondPlan);
+        const picker = new PickerController(() => undefined);
+        const workflow = new PackageBatchImportWorkflow({
+            transport: {
+                inspectPackage: vi.fn().mockResolvedValue(inspection('package-0', 'One', 1)),
+                planImagePackageImport,
+                releaseImagePackageImportPlan: vi.fn().mockResolvedValue(undefined),
+            } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker,
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn().mockResolvedValue(undefined),
+            refreshSession: vi.fn().mockResolvedValue(undefined),
+            setStatus: vi.fn(),
+        });
+
+        workflow.open({
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 0,
+            partitionIndex: 0,
+        });
+        const choosing = workflow.chooseWorkspace();
+        picker.finish([source]);
+        await choosing;
+        await workflow.replan();
+
+        expect(planImagePackageImport).toHaveBeenCalledTimes(2);
+        expect(workflow.request).toMatchObject({
+            plan: { planToken: 'suggested-plan-2', valid: false },
+            status: 'ready',
+            hasUnvalidatedChanges: false,
+        });
+    });
+
     it('previews unique server suggestions, replans edited names, and applies one atomic plan', async () => {
         const sources = [
             serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkvol' }, 'one.axkvol'),
@@ -130,6 +394,9 @@ describe('PackageBatchImportWorkflow', () => {
         picker.finish(sources);
         await choosing;
 
+        expect(planImagePackageImport).not.toHaveBeenCalled();
+        await workflow.replan();
+
         expect(workflow.request?.plan?.packages.map((item) => item.destinationVolumeName)).toEqual([
             'Drums',
             'Drums 2',
@@ -184,6 +451,68 @@ describe('PackageBatchImportWorkflow', () => {
         expect(workflow.request).toBeNull();
     });
 
+    it('accumulates multiple object rename drafts before one explicit replan', async () => {
+        const sources = [
+            serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkvol' }, 'one.axkvol'),
+            serverFileLocation({ rootId: 'workspace', relativePath: 'two.axkvol' }, 'two.axkvol'),
+        ];
+        const planImagePackageImport = vi
+            .fn()
+            .mockResolvedValueOnce(plan(['One', 'Two'], 'initial-plan'))
+            .mockResolvedValueOnce(plan(['One', 'Two'], 'renamed-plan'));
+        const picker = new PickerController(() => undefined);
+        const workflow = new PackageBatchImportWorkflow({
+            transport: {
+                inspectPackage: vi
+                    .fn()
+                    .mockResolvedValueOnce(inspection('package-0', 'One', 1))
+                    .mockResolvedValueOnce(inspection('package-1', 'Two', 1)),
+                planImagePackageImport,
+                releaseImagePackageImportPlan: vi.fn().mockResolvedValue(undefined),
+            } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker,
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn().mockResolvedValue(undefined),
+            refreshSession: vi.fn().mockResolvedValue(undefined),
+            setStatus: vi.fn(),
+        });
+        const partition: DiskTreeItem = {
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 1,
+            partitionIndex: 0,
+        };
+
+        workflow.open(partition);
+        const choosing = workflow.chooseWorkspace();
+        picker.finish(sources);
+        await choosing;
+
+        await workflow.replan();
+
+        const [one, two] = workflow.request!.items;
+        workflow.rename(one.id, 'sample-1', 'Kick fixed');
+        workflow.rename(two.id, 'sample-2', 'Snare fixed');
+
+        expect(workflow.request?.renames).toEqual({
+            [`${one.id}:sample-1`]: 'Kick fixed',
+            [`${two.id}:sample-2`]: 'Snare fixed',
+        });
+        expect(planImagePackageImport).toHaveBeenCalledTimes(1);
+
+        await workflow.replan();
+
+        expect(planImagePackageImport).toHaveBeenCalledTimes(2);
+        expect(planImagePackageImport.mock.calls[1][3]).toEqual([
+            { packageIndex: 0, nodeId: 'sample-1', destinationName: 'Kick fixed' },
+            { packageIndex: 1, nodeId: 'sample-2', destinationName: 'Snare fixed' },
+        ]);
+    });
+
     it('preserves package state while replanning and importing only selected packages', async () => {
         const sources = [
             serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkvol' }, 'one.axkvol'),
@@ -240,6 +569,8 @@ describe('PackageBatchImportWorkflow', () => {
         picker.finish(sources);
         await choosing;
 
+        await workflow.replan();
+
         const [one, two, three] = workflow.request!.items;
         expect(workflow.request?.items.every((item) => item.selected)).toBe(true);
         workflow.renameVolume(three.id, 'Three edited');
@@ -287,6 +618,77 @@ describe('PackageBatchImportWorkflow', () => {
         expect(setStatus).toHaveBeenCalledWith('Imported 2 packages');
     });
 
+    it('keeps multiple volume packages targeted at the selected existing volume', async () => {
+        const sources = [
+            serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkvol' }, 'one.axkvol'),
+            serverFileLocation({ rootId: 'workspace', relativePath: 'two.axkvol' }, 'two.axkvol'),
+        ];
+        const planImagePackageImport = vi.fn().mockResolvedValue(plan(['Target', 'Target'], 'volume-plan'));
+        const picker = new PickerController(() => undefined);
+        const volume: DiskTreeItem = {
+            id: 'volume-0',
+            name: 'Target',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const partition: DiskTreeItem = {
+            id: 'partition-0',
+            name: 'Partition 1',
+            kind: 'partition',
+            childCount: 1,
+            partitionIndex: 0,
+            children: [volume],
+        };
+        const workflow = new PackageBatchImportWorkflow({
+            transport: {
+                inspectPackage: vi
+                    .fn()
+                    .mockResolvedValueOnce(inspection('package-0', 'One', 1))
+                    .mockResolvedValueOnce(inspection('package-1', 'Two', 1)),
+                planImagePackageImport,
+                releaseImagePackageImportPlan: vi.fn().mockResolvedValue(undefined),
+            } as unknown as ImageTransport,
+            jobs: {} as JobController,
+            picker,
+            pickerHistory: new PackagePickerHistory(),
+            isDesktop: false,
+            sessionId: () => 17,
+            invalidateSession: vi.fn().mockResolvedValue(undefined),
+            refreshSession: vi.fn().mockResolvedValue(undefined),
+            setStatus: vi.fn(),
+            sourceItems: () => [partition],
+        });
+
+        workflow.open(volume);
+        const choosing = workflow.chooseWorkspace();
+        picker.finish(sources);
+        await choosing;
+
+        expect(workflow.request).toMatchObject({
+            destinationStrategy: 'shared',
+            destinationMode: 'existing',
+            destinationPartitionIndex: 0,
+            destinationVolumeName: 'Target',
+            plan: null,
+            hasUnvalidatedChanges: true,
+        });
+        expect(workflow.canUseSeparateVolumes()).toBe(true);
+        expect(planImagePackageImport).not.toHaveBeenCalled();
+
+        await workflow.replan();
+
+        expect(planImagePackageImport).toHaveBeenCalledWith(
+            17,
+            sources,
+            { kind: 'EXISTING_VOLUME', partitionIndex: 0, volumeName: 'Target' },
+            [],
+            [],
+            undefined,
+            [],
+        );
+    });
+
     it('plans mixed package kinds into one selected existing volume', async () => {
         const sources = [
             serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkprg' }, 'one.axkprg'),
@@ -334,6 +736,8 @@ describe('PackageBatchImportWorkflow', () => {
         picker.finish(sources);
         await choosing;
 
+        await workflow.replan();
+
         expect(workflow.request?.destinationStrategy).toBe('shared');
         expect(workflow.canUseSeparateVolumes()).toBe(false);
         expect(planImagePackageImport).toHaveBeenCalledWith(
@@ -404,7 +808,7 @@ describe('PackageBatchImportWorkflow', () => {
         );
     });
 
-    it('refreshes and replans automatically when the image changed before apply', async () => {
+    it('refreshes and waits for an explicit conflict check when the image changed before apply', async () => {
         const source = serverFileLocation({ rootId: 'workspace', relativePath: 'one.axkvol' }, 'one.axkvol');
         const planImagePackageImport = vi
             .fn()
@@ -452,10 +856,21 @@ describe('PackageBatchImportWorkflow', () => {
         const choosing = workflow.chooseWorkspace();
         picker.finish([source]);
         await choosing;
+        await workflow.replan();
         await workflow.apply();
 
         expect(refreshSession).toHaveBeenCalledWith({ partitionIndex: 0 });
         expect(releaseImagePackageImportPlan).toHaveBeenCalledWith('stale-plan');
+        expect(planImagePackageImport).toHaveBeenCalledTimes(1);
+        expect(workflow.request).toMatchObject({
+            plan: null,
+            status: 'ready',
+            hasUnvalidatedChanges: true,
+        });
+        expect(setStatus).toHaveBeenLastCalledWith('Image changed; check import conflicts again');
+
+        await workflow.replan();
+
         expect(planImagePackageImport).toHaveBeenCalledTimes(2);
         expect(planImagePackageImport).toHaveBeenLastCalledWith(
             17,
@@ -472,7 +887,6 @@ describe('PackageBatchImportWorkflow', () => {
         );
         expect(workflow.request?.plan?.planToken).toBe('fresh-plan');
         expect(workflow.request?.status).toBe('ready');
-        expect(setStatus).toHaveBeenLastCalledWith('Image changed; import conflicts checked again');
     });
 
     it('refreshes and closes after an already-submitted job cannot be confirmed', async () => {
@@ -521,6 +935,7 @@ describe('PackageBatchImportWorkflow', () => {
         const choosing = workflow.chooseWorkspace();
         picker.finish([source]);
         await choosing;
+        await workflow.replan();
         await workflow.apply();
 
         expect(refreshSession).toHaveBeenCalledWith({ partitionIndex: 0, volumeName: 'One' });
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
index cbd72a84..ff9d578c 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.svelte.ts
@@ -83,7 +83,7 @@ export class PackageImportWorkflow {
         this.abortController = null;
         const destination = initialImportDestination(item) ?? {
             mode: 'existing' as const,
-            partitionIndex: null,
+            partitionIndex: this.destinations().partitions[0]?.partitionIndex ?? null,
             volumeName: '',
         };
         this.request = {
@@ -132,19 +132,9 @@ export class PackageImportWorkflow {
         const request = this.request;
         if (!request || request.status === 'applying' || request.destinationMode === mode) return;
         const destinations = this.destinations();
-        const currentVolume = destinations.volumes.find(
-            (option) =>
-                option.partitionIndex === request.destinationPartitionIndex &&
-                option.volumeName === request.destinationVolumeName,
-        );
-        const partitionIndex =
-            mode === 'existing'
-                ? (currentVolume?.partitionIndex ?? null)
-                : (request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null);
+        const partitionIndex = request.destinationPartitionIndex ?? destinations.partitions[0]?.partitionIndex ?? null;
         const volumeName =
-            mode === 'existing'
-                ? (currentVolume?.volumeName ?? '')
-                : suggestedPackageVolumeName(request.sourceName, request.inspection);
+            mode === 'existing' ? '' : suggestedPackageVolumeName(request.sourceName, request.inspection);
         this.updateDestination(
             {
                 destinationMode: mode,
@@ -179,7 +169,13 @@ export class PackageImportWorkflow {
     setDestinationPartition(partitionIndex: number): void {
         const request = this.request;
         if (!request || request.status === 'applying' || request.destinationPartitionIndex === partitionIndex) return;
-        this.updateDestination({ destinationPartitionIndex: partitionIndex }, true);
+        this.updateDestination(
+            {
+                destinationPartitionIndex: partitionIndex,
+                ...(request.destinationMode === 'existing' ? { destinationVolumeName: '' } : {}),
+            },
+            true,
+        );
     }
 
     setDestinationVolumeName(volumeName: string): void {
diff --git a/apps/axkdeck/src/features/import/packageWorkflow.test.ts b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
index 35fa6c5f..71366255 100644
--- a/apps/axkdeck/src/features/import/packageWorkflow.test.ts
+++ b/apps/axkdeck/src/features/import/packageWorkflow.test.ts
@@ -824,7 +824,7 @@ describe('PackageImportWorkflow', () => {
         await workflow.requestDroppedFile(dropped);
 
         expect(workflow.request?.destinationMode).toBe('existing');
-        expect(workflow.request?.destinationPartitionIndex).toBeNull();
+        expect(workflow.request?.destinationPartitionIndex).toBe(0);
         expect(workflow.request?.destinationVolumeName).toBe('');
         expect(workflow.request?.plan).toBeNull();
         expect(workflow.request?.hasUnvalidatedChanges).toBe(true);
@@ -846,4 +846,42 @@ describe('PackageImportWorkflow', () => {
             [],
         );
     });
+
+    it('clears an existing volume atomically when its destination partition changes', () => {
+        const firstVolume: DiskTreeItem = {
+            id: 'volume-0',
+            name: 'First',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 0,
+        };
+        const secondVolume: DiskTreeItem = {
+            id: 'volume-1',
+            name: 'Second',
+            kind: 'volume',
+            childCount: 0,
+            partitionIndex: 1,
+        };
+        const workflow = new PackageImportWorkflow({
+            transport: {} as ImageTransport,
+            jobs: {} as JobController,
+            picker: new PickerController(() => undefined),
+            isDesktop: false,
+            sessionId: () => 17,
+            sourceItems: () => [firstVolume, secondVolume],
+            invalidateSession: vi.fn(),
+            refreshSession: vi.fn(),
+            setStatus: vi.fn(),
+        });
+
+        workflow.open(firstVolume);
+        workflow.setDestinationPartition(1);
+
+        expect(workflow.request).toMatchObject({
+            destinationMode: 'existing',
+            destinationPartitionIndex: 1,
+            destinationVolumeName: '',
+            plan: null,
+        });
+    });
 });
diff --git a/apps/axkdeck/src/features/mutation/workflow.svelte.ts b/apps/axkdeck/src/features/mutation/workflow.svelte.ts
index 5435320c..31fb8428 100644
--- a/apps/axkdeck/src/features/mutation/workflow.svelte.ts
+++ b/apps/axkdeck/src/features/mutation/workflow.svelte.ts
@@ -56,7 +56,7 @@ export class MutationWorkflow {
     volumeAvailable = $state(false);
     partitionAvailable = $state(false);
     objectRenameAvailable = $state(false);
-    volumeAction = $state<{ item: DiskTreeItem; action: ImageTreeAction } | null>(null);
+    volumeAction = $state<{ items: DiskTreeItem[]; action: ImageTreeAction } | null>(null);
     volumeActionBusy = $state(false);
     volumeActionPhase = $state<'idle' | 'checking' | 'submitting'>('idle');
     volumeActionError = $state('');
@@ -114,13 +114,30 @@ export class MutationWorkflow {
         if ((action === 'rename-volume' || action === 'delete-volume') && item.kind !== 'volume') return false;
         this.volumeActionError = '';
         this.volumeDeletionInspection = null;
-        const request = { item, action };
+        const request = { items: [item], action };
         const generation = ++this.volumeActionGeneration;
         this.volumeAction = request;
         if (action === 'delete-volume') void this.inspectVolumeDeletion(request, generation);
         return true;
     }
 
+    requestVolumeDeletion(items: DiskTreeItem[]): boolean {
+        if (!this.volumeAvailable || items.length === 0) return false;
+        const uniqueItems = new Map<string, DiskTreeItem>();
+        for (const item of items) {
+            if (item.kind !== 'volume' || item.partitionIndex === undefined) return false;
+            uniqueItems.set(`${item.partitionIndex}\0${item.name}`, item);
+        }
+        if (uniqueItems.size !== items.length) return false;
+        this.volumeActionError = '';
+        this.volumeDeletionInspection = null;
+        const request = { items: [...items], action: 'delete-volume' as const };
+        const generation = ++this.volumeActionGeneration;
+        this.volumeAction = request;
+        void this.inspectVolumeDeletion(request, generation);
+        return true;
+    }
+
     requestObjectRename(target: ObjectRenameTarget): void {
         if (!this.objectRenameAvailable || this.dependencies.sessionId() === null) return;
         this.objectRenameRequest = { target, busy: false, error: '' };
@@ -328,28 +345,36 @@ export class MutationWorkflow {
         if (!this.volumeAction || !this.dependencies.imageOpen()) return;
         const requested = this.volumeAction;
         if (requested.action === 'delete-volume' && !this.volumeDeletionInspection?.canDelete) return;
-        const partitionIndex = requested.item.partitionIndex;
+        const primaryItem = requested.items[0];
+        if (!primaryItem) return;
+        const partitionIndex = primaryItem.partitionIndex;
         if (partitionIndex === undefined) return;
-        const previousVolumeName = requested.item.kind === 'volume' ? requested.item.name : undefined;
-        const volumeMutation: VolumeMutation | null =
+        const previousVolumeName = primaryItem.kind === 'volume' ? primaryItem.name : undefined;
+        const volumeMutations: VolumeMutation[] =
             requested.action === 'add-volume'
-                ? { kind: 'add', partitionIndex, volumeName: name }
+                ? [{ kind: 'add', partitionIndex, volumeName: name }]
                 : requested.action === 'rename-volume'
-                  ? {
-                        kind: 'rename',
-                        partitionIndex,
-                        volumeName: requested.item.name,
-                        newVolumeName: name,
-                    }
+                  ? [
+                        {
+                            kind: 'rename',
+                            partitionIndex,
+                            volumeName: primaryItem.name,
+                            newVolumeName: name,
+                        },
+                    ]
                   : requested.action === 'delete-volume'
-                    ? { kind: 'delete', partitionIndex, volumeName: requested.item.name }
-                    : null;
+                    ? requested.items.map((item) => ({
+                          kind: 'delete' as const,
+                          partitionIndex: item.partitionIndex!,
+                          volumeName: item.name,
+                      }))
+                    : [];
         const partitionMutation: PartitionMutation | null =
             requested.action === 'rename-partition'
                 ? {
                       kind: 'rename',
                       partitionIndex,
-                      partitionName: requested.item.name,
+                      partitionName: primaryItem.name,
                       newPartitionName: name,
                   }
                 : null;
@@ -363,7 +388,7 @@ export class MutationWorkflow {
             requested.action === 'add-volume'
                 ? 'Adding volume'
                 : requested.action === 'delete-volume'
-                  ? 'Deleting volume'
+                  ? `Deleting ${requested.items.length} ${requested.items.length === 1 ? 'volume' : 'volumes'}`
                   : requested.action === 'rename-partition'
                     ? 'Renaming partition'
                     : 'Renaming volume',
@@ -381,7 +406,7 @@ export class MutationWorkflow {
                 () =>
                     partitionMutation
                         ? this.dependencies.transport.startPartitionMutation(sessionId, partitionMutation)
-                        : this.dependencies.transport.startVolumeMutation(sessionId, volumeMutation!),
+                        : this.dependencies.transport.startVolumeMutations(sessionId, volumeMutations),
                 (update) => {
                     if (update.progress?.label) this.dependencies.setStatus(update.progress.label);
                 },
@@ -392,7 +417,7 @@ export class MutationWorkflow {
             ++this.volumeActionGeneration;
             this.volumeAction = null;
             await this.dependencies.refreshSession({ partitionIndex, volumeName: preferredVolumeName });
-            this.dependencies.reportTiming(requested.action, started, 1);
+            this.dependencies.reportTiming(requested.action, started, requested.items.length);
         } catch (error) {
             this.volumeActionError = userFacingMessage(error);
             this.dependencies.setStatus(this.volumeActionError);
@@ -408,12 +433,11 @@ export class MutationWorkflow {
     }
 
     private async inspectVolumeDeletion(
-        requested: { item: DiskTreeItem; action: ImageTreeAction },
+        requested: { items: DiskTreeItem[]; action: ImageTreeAction },
         generation: number,
     ): Promise<void> {
-        const partitionIndex = requested.item.partitionIndex;
         const sessionId = this.dependencies.sessionId();
-        if (partitionIndex === undefined || sessionId === null) {
+        if (sessionId === null) {
             if (this.isCurrentVolumeAction(generation)) {
                 this.volumeActionError = 'Image session is no longer available';
             }
@@ -425,8 +449,10 @@ export class MutationWorkflow {
         try {
             const inspection = await this.dependencies.transport.inspectVolumeDeletion(
                 sessionId,
-                partitionIndex,
-                requested.item.name,
+                requested.items.map((item) => ({
+                    partitionIndex: item.partitionIndex!,
+                    volumeName: item.name,
+                })),
             );
             if (this.isCurrentVolumeAction(generation)) this.volumeDeletionInspection = inspection;
         } catch (error) {
diff --git a/apps/axkdeck/src/features/mutation/workflow.test.ts b/apps/axkdeck/src/features/mutation/workflow.test.ts
index 5121a94e..78d21939 100644
--- a/apps/axkdeck/src/features/mutation/workflow.test.ts
+++ b/apps/axkdeck/src/features/mutation/workflow.test.ts
@@ -89,6 +89,7 @@ describe('MutationWorkflow', () => {
                 categoryName: 'SBNK',
                 sfsId: 1,
                 storedSizeBytes: 512,
+                sizeWithDependenciesBytes: null,
                 sampleRate: 44_100,
                 rootKey: 60,
                 frameCount: 1,
@@ -142,6 +143,7 @@ describe('MutationWorkflow', () => {
                 categoryName: 'SBNK',
                 sfsId: 1,
                 storedSizeBytes: 512,
+                sizeWithDependenciesBytes: null,
                 sampleRate: 44_100,
                 rootKey: 60,
                 frameCount: 1,
@@ -222,6 +224,7 @@ describe('MutationWorkflow', () => {
                 categoryName: 'SBNK',
                 sfsId: 1,
                 storedSizeBytes: 512,
+                sizeWithDependenciesBytes: null,
                 sampleRate: 44_100,
                 rootKey: 60,
                 frameCount: 1,
@@ -281,6 +284,7 @@ describe('MutationWorkflow', () => {
                 categoryName: 'SBNK',
                 sfsId: 1,
                 storedSizeBytes: 512,
+                sizeWithDependenciesBytes: null,
                 sampleRate: 44_100,
                 rootKey: 60,
                 frameCount: 1,
@@ -325,23 +329,59 @@ describe('MutationWorkflow', () => {
         const inspectVolumeDeletion = vi.fn().mockResolvedValue({
             imageId: 'image-1',
             revision: 1,
-            partitionIndex: 0,
-            volumeName: 'Samples',
+            targets: [{ partitionIndex: 0, volumeName: 'Samples' }],
             canDelete: false,
             crossingRelationshipCount: 1,
             blockers: [{ code: 'KNOWN_RELATIONSHIP_CROSSES_VOLUME', message: 'Crossing link', count: 1 }],
         });
-        const startVolumeMutation = vi.fn();
-        const { workflow } = workflowWith({ inspectVolumeDeletion, startVolumeMutation });
+        const startVolumeMutations = vi.fn();
+        const { workflow } = workflowWith({ inspectVolumeDeletion, startVolumeMutations });
 
         expect(workflow.requestVolumeAction(volume, 'delete-volume')).toBe(true);
         await vi.waitFor(() => expect(workflow.volumeDeletionInspection?.canDelete).toBe(false));
         await workflow.submitVolumeAction('Samples');
 
-        expect(startVolumeMutation).not.toHaveBeenCalled();
+        expect(startVolumeMutations).not.toHaveBeenCalled();
         expect(workflow.placementRepairRequest).toBeNull();
     });
 
+    it('deletes multiple volumes in one alteration job after inspecting their union', async () => {
+        const secondVolume = { ...volume, id: 'volume-2', name: 'Programs', partitionIndex: 2 };
+        const targets = [
+            { partitionIndex: 0, volumeName: 'Samples' },
+            { partitionIndex: 2, volumeName: 'Programs' },
+        ];
+        const inspectVolumeDeletion = vi.fn().mockResolvedValue({
+            imageId: 'image-1',
+            revision: 1,
+            targets,
+            canDelete: true,
+            crossingRelationshipCount: 0,
+            blockers: [],
+        });
+        const startVolumeMutations = vi.fn().mockResolvedValue({ jobId: 1, status: 'queued' });
+        const { workflow, refreshSession } = workflowWith({ inspectVolumeDeletion, startVolumeMutations });
+
+        expect(workflow.requestVolumeDeletion([volume, secondVolume])).toBe(true);
+        await vi.waitFor(() => expect(workflow.volumeDeletionInspection?.canDelete).toBe(true));
+        await workflow.submitVolumeAction('');
+
+        expect(inspectVolumeDeletion).toHaveBeenCalledWith(7, targets);
+        expect(startVolumeMutations).toHaveBeenCalledWith(7, [
+            { kind: 'delete', partitionIndex: 0, volumeName: 'Samples' },
+            { kind: 'delete', partitionIndex: 2, volumeName: 'Programs' },
+        ]);
+        expect(refreshSession).toHaveBeenCalledWith({ partitionIndex: 0, volumeName: undefined });
+    });
+
+    it('rejects duplicate deletion targets even when their tree ids differ', () => {
+        const duplicateVolume = { ...volume, id: 'duplicate-volume' };
+        const { workflow } = workflowWith({});
+
+        expect(workflow.requestVolumeDeletion([volume, duplicateVolume])).toBe(false);
+        expect(workflow.volumeAction).toBeNull();
+    });
+
     it('repairs a uniquely attributable volume placement through the explicit action', async () => {
         const inspectPlacement = vi
             .fn()
diff --git a/apps/axkdeck/src/features/sequence/SequenceWorkspace.test.ts b/apps/axkdeck/src/features/sequence/SequenceWorkspace.test.ts
index ff1a31bd..4585e52d 100644
--- a/apps/axkdeck/src/features/sequence/SequenceWorkspace.test.ts
+++ b/apps/axkdeck/src/features/sequence/SequenceWorkspace.test.ts
@@ -16,6 +16,7 @@ function sequence(name: string, eventCount: number): SequenceItem {
         categoryName: 'SEQU',
         sfsId: 1,
         storedSizeBytes: 512,
+        sizeWithDependenciesBytes: null,
         sampleRate: 0,
         rootKey: 0,
         frameCount: 0,
diff --git a/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte b/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
index 05e0c4fe..e78fa565 100644
--- a/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
+++ b/apps/axkdeck/src/features/workspace/WorkspaceShell.svelte
@@ -32,7 +32,7 @@
         WaveDataItem,
         WorkspaceView,
     } from '../../lib/types';
-    import type { PackageExportSelectionState } from '../../lib/objectSelection';
+    import type { ObjectSelectionMode, PackageExportSelectionState } from '../../lib/objectSelection';
     import { desktopBuildInfo, type DesktopBuildInfo, type DesktopBuildInfoState } from '../../lib/desktopBuildInfo';
 
     interface WorkspaceTab {
@@ -51,6 +51,7 @@
         imageLocation: ImageLocation | null;
         sourceItems: DiskTreeItem[];
         selectedSource: DiskTreeItem;
+        selectedVolumeIds: readonly string[];
         imageOpening: boolean;
         sessionId: number | null;
         catalog: CatalogWorkflow;
@@ -84,13 +85,15 @@
         sequenceExportAvailable: boolean;
         mediaConversionAvailable: boolean;
         allocationInspectionAvailable: boolean;
+        samplerOrderingEnabled?: boolean;
         openConnectionSettings: () => void;
         openImage: () => void;
         createImage: () => void;
         closeImage: () => void;
         showImageIntegrity: () => void;
         manageLocations: () => void;
-        selectSource: (item: DiskTreeItem) => void;
+        selectSource: (item: DiskTreeItem, mode: ObjectSelectionMode, visibleVolumes: readonly DiskTreeItem[]) => void;
+        selectSourceForContext: (item: DiskTreeItem, visibleVolumes: readonly DiskTreeItem[]) => void;
         imageAction: (item: DiskTreeItem, action: ImageTreeAction) => void;
         selectWorkspace: (view: WorkspaceView) => void;
         exportPackage: (items: PackageExportObject[]) => void;
@@ -114,6 +117,7 @@
         imageLocation,
         sourceItems,
         selectedSource,
+        selectedVolumeIds,
         imageOpening,
         sessionId,
         catalog,
@@ -147,6 +151,7 @@
         sequenceExportAvailable,
         mediaConversionAvailable,
         allocationInspectionAvailable,
+        samplerOrderingEnabled = false,
         openConnectionSettings,
         openImage,
         createImage,
@@ -154,6 +159,7 @@
         showImageIntegrity,
         manageLocations,
         selectSource,
+        selectSourceForContext,
         imageAction,
         selectWorkspace,
         exportPackage,
@@ -354,6 +360,7 @@
             image={imageLocation}
             items={sourceItems}
             selectedId={selectedSource.id}
+            {selectedVolumeIds}
             opening={imageOpening}
             storageLocationsAvailable={transport.storageMode === 'server'}
             onopen={openImage}
@@ -362,6 +369,7 @@
             onintegrity={showImageIntegrity}
             onmanagelocations={manageLocations}
             onselect={selectSource}
+            oncontextselect={selectSourceForContext}
             volumeActionsEnabled={mutation.volumeAvailable}
             partitionActionsEnabled={mutation.partitionAvailable}
             packageImportEnabled={packageImportAvailable}
@@ -371,6 +379,7 @@
             audioExportEnabled={audioExportAvailable}
             mediaConversionEnabled={mediaConversionAvailable}
             allocationInspectionEnabled={allocationInspectionAvailable}
+            {samplerOrderingEnabled}
             onimageaction={imageAction}
             onloadchildren={(parentId, offset, limit) =>
                 sessionId === null
diff --git a/apps/axkdeck/src/lib/allocationInspector.test.ts b/apps/axkdeck/src/lib/allocationInspector.test.ts
index d9bddf87..680ed64e 100644
--- a/apps/axkdeck/src/lib/allocationInspector.test.ts
+++ b/apps/axkdeck/src/lib/allocationInspector.test.ts
@@ -8,11 +8,39 @@ import {
     allocationExportFilename,
     allocationSpaceStatistic,
     formatAllocationBytes,
+    resolveAllocationServerConnection,
     saveAllocationMap,
 } from './allocationInspector';
 
 describe('allocation inspector presentation', () => {
-    beforeEach(() => mocks.invoke.mockReset());
+    beforeEach(() => {
+        mocks.invoke.mockReset();
+        delete window.__AXKLIB_SERVER__;
+    });
+
+    it('retrieves the shared desktop connection for a secondary allocation window', async () => {
+        const connection = {
+            mode: 'local',
+            baseUrl: 'http://127.0.0.1:42101/api/v1',
+            bearerToken: 'test-token',
+        } as const;
+        mocks.invoke.mockResolvedValue(connection);
+
+        await expect(resolveAllocationServerConnection()).resolves.toEqual(connection);
+        expect(mocks.invoke).toHaveBeenCalledWith('server_connection');
+        expect(window.__AXKLIB_SERVER__).toEqual(connection);
+    });
+
+    it('reuses a connection already available in the allocation window', async () => {
+        window.__AXKLIB_SERVER__ = {
+            mode: 'remote',
+            baseUrl: 'https://example.test/api/v1',
+            bearerToken: 'test-token',
+        };
+
+        await expect(resolveAllocationServerConnection()).resolves.toEqual(window.__AXKLIB_SERVER__);
+        expect(mocks.invoke).not.toHaveBeenCalled();
+    });
 
     it('presents free clusters as allocatable bytes with the cluster count retained', () => {
         expect(allocationSpaceStatistic(10, 1024)).toEqual({ primary: '10 KiB', secondary: '10 clusters' });
diff --git a/apps/axkdeck/src/lib/allocationInspector.ts b/apps/axkdeck/src/lib/allocationInspector.ts
index 12823c25..ce2e64b2 100644
--- a/apps/axkdeck/src/lib/allocationInspector.ts
+++ b/apps/axkdeck/src/lib/allocationInspector.ts
@@ -12,6 +12,15 @@ export interface AllocationMapSaveRequest {
     document: unknown;
 }
 
+type ServerConnection = NonNullable<Window['__AXKLIB_SERVER__']>;
+
+export async function resolveAllocationServerConnection(): Promise<ServerConnection | null> {
+    if (window.__AXKLIB_SERVER__) return window.__AXKLIB_SERVER__;
+    const connection = await invoke<ServerConnection | null>('server_connection');
+    window.__AXKLIB_SERVER__ = connection ?? undefined;
+    return connection;
+}
+
 export function formatAllocationBytes(bytes: number): string {
     if (bytes < 1024) return `${bytes.toLocaleString()} B`;
     const units = ['KiB', 'MiB', 'GiB'];
diff --git a/apps/axkdeck/src/lib/components/AboutDialog.svelte b/apps/axkdeck/src/lib/components/AboutDialog.svelte
index 0361d159..6d65b689 100644
--- a/apps/axkdeck/src/lib/components/AboutDialog.svelte
+++ b/apps/axkdeck/src/lib/components/AboutDialog.svelte
@@ -40,11 +40,11 @@
                 <dl>
                     <div>
                         <dt>Version</dt>
-                        <dd>{state.buildInfo.semanticVersion}</dd>
-                    </div>
-                    <div>
-                        <dt>Build</dt>
-                        <dd>{state.buildInfo.sourceIdentity}</dd>
+                        <dd>
+                            {state.buildInfo.isRelease
+                                ? state.buildInfo.semanticVersion
+                                : state.buildInfo.sourceIdentity}
+                        </dd>
                     </div>
                     <div>
                         <dt>Web view</dt>
diff --git a/apps/axkdeck/src/lib/components/AboutDialog.test.ts b/apps/axkdeck/src/lib/components/AboutDialog.test.ts
index d2ce29a0..3fe095f5 100644
--- a/apps/axkdeck/src/lib/components/AboutDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/AboutDialog.test.ts
@@ -17,7 +17,7 @@ describe('AboutDialog', () => {
         await waitFor(() => expect(document.activeElement).toBe(within(dialog).getByRole('button', { name: 'Close' })));
     });
 
-    it('renders version and source identity and closes with Escape', async () => {
+    it('renders the source identity as the version for a branch build and closes with Escape', async () => {
         const onclose = vi.fn();
         render(AboutDialog, {
             props: {
@@ -25,9 +25,9 @@ describe('AboutDialog', () => {
                     status: 'ready',
                     buildInfo: {
                         schemaVersion: 1,
-                        semanticVersion: '0.4.0',
+                        semanticVersion: '0.4.0-pre',
                         projectVersion: '0.4.0',
-                        sourceIdentity: 'v0.4.0-1234567-mod',
+                        sourceIdentity: '0.4.0-pre-dirty-1234567',
                         releaseTag: '',
                         isRelease: false,
                         webviewEngine: 'Microsoft Edge WebView2',
@@ -39,14 +39,40 @@ describe('AboutDialog', () => {
         });
 
         const dialog = screen.getByRole('dialog', { name: 'About axkdeck' });
-        expect(within(dialog).getByText('0.4.0')).toBeTruthy();
-        expect(within(dialog).getByText('v0.4.0-1234567-mod')).toBeTruthy();
+        expect(within(dialog).getByText('0.4.0-pre-dirty-1234567')).toBeTruthy();
+        expect(within(dialog).queryByText('0.4.0-pre')).toBeNull();
+        expect(within(dialog).queryByText('Build')).toBeNull();
         expect(within(dialog).getByText('Microsoft Edge WebView2 120.0.2210.144')).toBeTruthy();
 
         await fireEvent.keyDown(dialog, { key: 'Escape' });
         expect(onclose).toHaveBeenCalledOnce();
     });
 
+    it('renders the canonical semantic version for a tagged release', () => {
+        render(AboutDialog, {
+            props: {
+                state: {
+                    status: 'ready',
+                    buildInfo: {
+                        schemaVersion: 1,
+                        semanticVersion: '0.4.0',
+                        projectVersion: '0.4.0',
+                        sourceIdentity: 'v0.4.0-1234567',
+                        releaseTag: 'v0.4.0',
+                        isRelease: true,
+                        webviewEngine: 'WebKitGTK',
+                        webviewVersion: '2.50.4',
+                    },
+                },
+                onclose: vi.fn(),
+            },
+        });
+
+        const dialog = screen.getByRole('dialog', { name: 'About axkdeck' });
+        expect(within(dialog).getByText('0.4.0')).toBeTruthy();
+        expect(within(dialog).queryByText('v0.4.0-1234567')).toBeNull();
+    });
+
     it('keeps build information available when webview introspection fails', () => {
         render(AboutDialog, {
             props: {
@@ -56,7 +82,7 @@ describe('AboutDialog', () => {
                         schemaVersion: 1,
                         semanticVersion: '0.4.0',
                         projectVersion: '0.4.0',
-                        sourceIdentity: 'v0.4.0-1234567-mod',
+                        sourceIdentity: 'main-dirty-1234567',
                         releaseTag: '',
                         isRelease: false,
                         webviewEngine: 'WebKitGTK',
@@ -69,7 +95,7 @@ describe('AboutDialog', () => {
 
         const dialog = screen.getByRole('dialog', { name: 'About axkdeck' });
         expect(within(dialog).getByText('WebKitGTK unavailable')).toBeTruthy();
-        expect(within(dialog).getByText('v0.4.0-1234567-mod')).toBeTruthy();
+        expect(within(dialog).getByText('main-dirty-1234567')).toBeTruthy();
     });
 
     it('shows a stable fallback when build information cannot be loaded', () => {
diff --git a/apps/axkdeck/src/lib/components/AudioImportDialog.svelte b/apps/axkdeck/src/lib/components/AudioImportDialog.svelte
index a7361759..d102c1c5 100644
--- a/apps/axkdeck/src/lib/components/AudioImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/AudioImportDialog.svelte
@@ -558,7 +558,7 @@
         display: grid;
         gap: 5px;
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-body-font-size);
     }
     .import-target-settings {
         display: grid;
@@ -569,7 +569,7 @@
         display: grid;
         gap: 5px;
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-label-font-size);
     }
     .import-target-settings select,
     .import-target-settings input {
@@ -578,7 +578,7 @@
     .field-error {
         margin: 0;
         color: var(--color-danger);
-        font-size: 11px;
+        font-size: var(--dialog-body-font-size);
     }
     .inspection-progress progress {
         width: 100%;
diff --git a/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts b/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
index e3b8be12..5d8c438f 100644
--- a/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/AudioImportDialog.test.ts
@@ -9,6 +9,10 @@ import type { ClientUploadSource } from '../clientUploadSource';
 import type { AudioImportCapabilities, AudioSourceInfo, ImageTransport } from '../transport';
 import AudioImportDialog from './AudioImportDialog.svelte';
 
+const audioImportDialogSource = readFileSync(
+    resolve(process.cwd(), 'src/lib/components/AudioImportDialog.svelte'),
+    'utf8',
+);
 const audioImportRowsSource = readFileSync(resolve(process.cwd(), 'src/lib/components/AudioImportRows.svelte'), 'utf8');
 const audioSamplerSettingsSource = readFileSync(
     resolve(process.cwd(), 'src/lib/components/AudioSamplerSettings.svelte'),
@@ -99,13 +103,31 @@ function destinationProps(volumeName: string, partitionIndex = 0) {
 }
 
 describe('AudioImportDialog', () => {
-    it('keeps sampler fields aligned while reserving clearance for the scrollbar', () => {
-        expect(audioSamplerSettingsSource).toContain('grid-template-columns: repeat(7, minmax(0, 1fr));');
-        expect(audioSamplerSettingsSource).not.toContain('repeat(auto-fit');
+    it('owns the compact spacing around the reusable destination chooser', () => {
+        expect(audioImportDialogSource).toMatch(/\.audio-import-body\s*\{[^}]*gap:\s*10px;/s);
+    });
+
+    it('left-packs sampler fields independently from the identity columns', () => {
+        expect(audioSamplerSettingsSource).toMatch(
+            /\.settings-fields\s*\{[^}]*display:\s*flex;[^}]*flex-wrap:\s*wrap;[^}]*justify-content:\s*flex-start;/s,
+        );
+        expect(audioSamplerSettingsSource).toMatch(/\.settings-fields\s*>\s*label\s*\{[^}]*flex:\s*0 0 auto;/s);
+        expect(audioSamplerSettingsSource).not.toContain('grid-template-columns: repeat(7');
         expect(audioImportRowsSource).toContain('padding-right: 12px;');
         expect(audioImportRowsSource).toContain('scrollbar-gutter: stable;');
     });
 
+    it('keeps each audio file compact while allowing its source details to wrap', () => {
+        expect(audioImportRowsSource).toContain('<small class="audio-import-file-metadata">');
+        expect(audioImportRowsSource).toMatch(
+            /\.audio-import-file-heading\s*\{[^}]*display:\s*flex;[^}]*flex-wrap:\s*wrap;/,
+        );
+        expect(audioImportRowsSource).toMatch(/\.audio-import-rows\s*\{[^}]*gap:\s*6px;/);
+        expect(audioImportRowsSource).toMatch(/\.audio-import-card\s*\{[^}]*gap:\s*6px;[^}]*padding:\s*8px 10px;/);
+        expect(audioImportRowsSource).toMatch(/\.identity-fields\s*\{[^}]*gap:\s*6px 10px;/);
+        expect(audioSamplerSettingsSource).toMatch(/\.settings-fields\s*\{[^}]*gap:\s*6px 10px;/);
+    });
+
     it('imports inspected Samples into a newly named Sample Bank', async () => {
         const oncommit = vi.fn().mockResolvedValue(undefined);
         render(AudioImportDialog, {
diff --git a/apps/axkdeck/src/lib/components/AudioImportRows.svelte b/apps/axkdeck/src/lib/components/AudioImportRows.svelte
index c0851ffb..e5976b3f 100644
--- a/apps/axkdeck/src/lib/components/AudioImportRows.svelte
+++ b/apps/axkdeck/src/lib/components/AudioImportRows.svelte
@@ -79,39 +79,45 @@
             <header class="card-header">
                 <div class="audio-import-file">
                     <div class="audio-import-file-heading">
-                        <strong title={row.fileName}>{row.fileName}</strong>
-                        {#if row.status === 'ready' && row.inspection?.valid}
-                            <button
-                                class="icon-button audition-button"
-                                type="button"
-                                aria-label={`${auditionActive ? 'Stop' : 'Play'} ${row.fileName}`}
-                                aria-pressed={auditionActive}
-                                title={auditionActive ? 'Stop preview' : 'Play preview'}
-                                disabled={busy}
-                                onclick={() => onaudition(row)}
-                            >
-                                <Icon name={auditionActive ? 'stop' : 'play'} size={14} />
-                            </button>
+                        <div class="audio-import-file-name">
+                            <strong title={row.fileName}>{row.fileName}</strong>
+                            {#if row.status === 'ready' && row.inspection?.valid}
+                                <button
+                                    class="icon-button audition-button"
+                                    type="button"
+                                    aria-label={`${auditionActive ? 'Stop' : 'Play'} ${row.fileName}`}
+                                    aria-pressed={auditionActive}
+                                    title={auditionActive ? 'Stop preview' : 'Play preview'}
+                                    disabled={busy}
+                                    onclick={() => onaudition(row)}
+                                >
+                                    <Icon name={auditionActive ? 'stop' : 'play'} size={14} />
+                                </button>
+                            {/if}
+                        </div>
+                        {#if row.status === 'uploading'}
+                            <small class="audio-import-file-metadata">
+                                Uploading {Math.round(row.progress * 100)}%
+                            </small>
+                        {:else if row.status === 'failed'}
+                            <small class="audio-import-file-metadata error-text">Upload or inspection failed</small>
+                        {:else if row.inspection}
+                            <small class="audio-import-file-metadata">
+                                {row.inspection.sourceFormat}
+                                {row.inspection.sourceSubtype} ·
+                                {row.inspection.channels === 2 ? 'Stereo' : 'Mono'} ·
+                                {row.inspection.sourceSampleRate.toLocaleString()} Hz ·
+                                {conversionDescription(row.inspection)}
+                                · {row.inspection.durationSeconds.toFixed(2)} s
+                            </small>
+                        {:else}
+                            <small class="audio-import-file-metadata">Waiting</small>
                         {/if}
                     </div>
-                    {#if row.status === 'uploading'}
-                        <small>Uploading {Math.round(row.progress * 100)}%</small>
-                    {:else if row.status === 'failed'}
-                        <small class="error-text">Upload or inspection failed</small>
-                    {:else if row.inspection}
-                        <small>
-                            {row.inspection.sourceFormat}
-                            {row.inspection.sourceSubtype} ·
-                            {row.inspection.channels === 2 ? 'Stereo' : 'Mono'} ·
-                            {row.inspection.sourceSampleRate.toLocaleString()} Hz ·
-                            {conversionDescription(row.inspection)}
-                            · {row.inspection.durationSeconds.toFixed(2)} s
-                        </small>
-                    {:else}
-                        <small>Waiting</small>
-                    {/if}
                     {#if !committing && audition.rowId === row.id && audition.status === 'failed'}
-                        <small class="error-text">Preview unavailable: {audition.error}</small>
+                        <small class="audio-import-file-note error-text">
+                            Preview unavailable: {audition.error}
+                        </small>
                     {/if}
                 </div>
                 <div class="card-header-actions">
@@ -238,26 +244,26 @@
     .audio-import-summary {
         margin: 0;
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-body-font-size);
     }
     .audio-import-rows {
         display: grid;
         min-height: 0;
-        gap: 8px;
+        gap: 6px;
         overflow-y: auto;
         padding-right: 12px;
         scrollbar-gutter: stable;
     }
     .audio-import-card {
         display: grid;
-        gap: 10px;
+        gap: 6px;
         min-width: 0;
-        padding: 11px 12px;
+        padding: 8px 10px;
         border: 1px solid var(--color-border);
         border-radius: 6px;
         background: rgb(255 255 255 / 1.5%);
         color: var(--color-text);
-        font-size: 12px;
+        font-size: var(--dialog-body-font-size);
     }
     .card-header {
         display: grid;
@@ -271,15 +277,24 @@
     .audio-import-file-heading {
         display: flex;
         align-items: center;
-        gap: 5px;
+        flex-wrap: wrap;
+        gap: 2px 8px;
         min-width: 0;
     }
+    .audio-import-file-name {
+        display: flex;
+        align-items: center;
+        flex: 0 1 auto;
+        gap: 4px;
+        min-width: 0;
+        max-width: 100%;
+    }
     .audio-import-file strong {
         display: block;
         min-width: 0;
         overflow: hidden;
         color: var(--color-text-strong);
-        font-size: 12px;
+        font-size: var(--dialog-section-font-size);
         font-weight: 600;
         line-height: 1.35;
         text-overflow: ellipsis;
@@ -295,14 +310,18 @@
     .audition-button[aria-pressed='true'] {
         color: var(--color-text-strong);
     }
-    .audio-import-file small {
-        display: block;
-        overflow: hidden;
-        margin-top: 3px;
+    .audio-import-file-metadata {
+        min-width: 0;
+        flex: 1 1 340px;
         color: var(--color-text-muted);
-        font-size: 11px;
-        text-overflow: ellipsis;
-        white-space: nowrap;
+        font-size: var(--dialog-metadata-font-size);
+        line-height: 1.35;
+    }
+    .audio-import-file-note {
+        display: block;
+        margin-top: 2px;
+        font-size: var(--dialog-metadata-font-size);
+        line-height: 1.35;
     }
     .card-header-actions {
         display: flex;
@@ -314,7 +333,7 @@
     .identity-fields {
         display: grid;
         grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
-        gap: 9px 12px;
+        gap: 6px 10px;
     }
     label {
         display: grid;
@@ -336,7 +355,7 @@
         align-items: flex-start;
         gap: 6px;
         max-width: 420px;
-        font-size: 11px;
+        font-size: var(--dialog-metadata-font-size);
         line-height: 1.35;
         overflow-wrap: anywhere;
     }
@@ -353,7 +372,7 @@
     }
     .status-neutral {
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-metadata-font-size);
     }
     .details-button {
         position: relative;
diff --git a/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte b/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte
index 0a3a87fb..d381260e 100644
--- a/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte
+++ b/apps/axkdeck/src/lib/components/AudioSamplerSettings.svelte
@@ -101,7 +101,7 @@
                 />
             </span>
         </label>
-        <label>
+        <label class="playback-setting">
             <span>Playback</span>
             <select
                 class="dialog-field-control"
@@ -121,7 +121,7 @@
             </select>
         </label>
         {#if row.loopMode === 1}
-            <label>
+            <label class="frame-setting">
                 <span>Loop start</span>
                 <input
                     class="dialog-field-control"
@@ -134,7 +134,7 @@
                     oninput={(event) => onupdate(row.id, { loopStartFrame: numberValue(event) })}
                 />
             </label>
-            <label>
+            <label class="frame-setting">
                 <span>Loop length</span>
                 <input
                     class="dialog-field-control"
@@ -153,13 +153,17 @@
 <style>
     .sampler-settings {
         display: grid;
-        gap: 9px;
-        padding: 2px 0;
+        gap: 6px;
     }
     .settings-fields {
-        display: grid;
-        grid-template-columns: repeat(7, minmax(0, 1fr));
-        gap: 9px 12px;
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: flex-start;
+        align-items: flex-end;
+        gap: 6px 10px;
+    }
+    .settings-fields > label {
+        flex: 0 0 auto;
     }
     label {
         display: grid;
@@ -189,22 +193,15 @@
     .unit-input small,
     .range-inputs span {
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-metadata-font-size);
         white-space: nowrap;
     }
-    @media (max-width: 1120px) {
-        .settings-fields {
-            grid-template-columns: repeat(4, minmax(130px, 1fr));
-        }
-    }
-    @media (max-width: 740px) {
-        .settings-fields {
-            grid-template-columns: repeat(2, minmax(130px, 1fr));
-        }
+    .playback-setting {
+        width: 180px;
+        max-width: 100%;
     }
-    @media (max-width: 460px) {
-        .settings-fields {
-            grid-template-columns: minmax(0, 1fr);
-        }
+    .frame-setting {
+        width: 140px;
+        max-width: 100%;
     }
 </style>
diff --git a/apps/axkdeck/src/lib/components/CompanionDiskDialog.svelte b/apps/axkdeck/src/lib/components/CompanionDiskDialog.svelte
index b483ffc6..63f24a04 100644
--- a/apps/axkdeck/src/lib/components/CompanionDiskDialog.svelte
+++ b/apps/axkdeck/src/lib/components/CompanionDiskDialog.svelte
@@ -130,7 +130,7 @@
 
     .companion-disk-content h3 {
         margin: 0 0 8px;
-        font-size: 12px;
+        font-size: var(--dialog-section-font-size);
         font-weight: 600;
     }
 
diff --git a/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.svelte b/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.svelte
index 8c4f6963..d7be7703 100644
--- a/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.svelte
+++ b/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.svelte
@@ -22,17 +22,15 @@
     import CollectionToolbar from './CollectionToolbar.svelte';
     import Icon from './Icon.svelte';
     import ObjectContextMenu from './ObjectContextMenu.svelte';
-
+    import ObjectSizeIdentity from './ObjectSizeIdentity.svelte';
     type ContainedView = 'sample-banks' | 'samples';
     type LaneId = 'primary' | 'secondary' | 'tertiary';
     const containedRowExtent = 26;
-
     interface LaneQueries {
         primary: string;
         secondary: string;
         tertiary: string;
     }
-
     interface Props {
         view: ContainedView;
         sampleBanks: SampleStructureItem[];
@@ -74,7 +72,6 @@
         onselectionchange?: (selection: PackageExportSelectionState) => void;
         onselectionlimit?: () => void;
     }
-
     let {
         view,
         sampleBanks,
@@ -129,7 +126,6 @@
     } | null>(null);
     let sampleViewport = $state<VirtualViewportState>({ scrollTop: 0, height: 0 });
     let waveDataViewport = $state<VirtualViewportState>({ scrollTop: 0, height: 0 });
-
     const sampleQuery = $derived(view === 'sample-banks' ? queries.secondary : queries.primary);
     const waveDataQuery = $derived(view === 'sample-banks' ? queries.tertiary : queries.secondary);
     const orderedBanks = $derived(sampleBanks.toSorted(compareNamedItems));
@@ -145,7 +141,6 @@
     const waveDataWindow = $derived(fixedVirtualWindow(filteredWaveData.length, waveDataViewport, containedRowExtent));
     const visibleSamples = $derived(filteredSamples.slice(sampleWindow.startIndex, sampleWindow.endIndex));
     const visibleWaveData = $derived(filteredWaveData.slice(waveDataWindow.startIndex, waveDataWindow.endIndex));
-
     function updateSampleViewport(viewport: VirtualViewportState): void {
         sampleViewport = viewport;
     }
@@ -458,9 +453,11 @@
                             oncontextmenu={(event) => openObjectMenu(event, 'sample-banks', orderedBanks, item)}
                             onkeydown={(event) => handleContainedKeyboard(event, 'sample-banks', index, item)}
                         >
-                            <strong>{item.name}</strong>
-                            <small>{item.memberCount ?? 0} {(item.memberCount ?? 0) === 1 ? 'Sample' : 'Samples'}</small
-                            >
+                            <ObjectSizeIdentity
+                                name={item.name}
+                                object={item.object}
+                                metadata={`${item.memberCount ?? 0} ${(item.memberCount ?? 0) === 1 ? 'Sample' : 'Samples'}`}
+                            />
                         </button>
                         <button
                             class="contained-playback icon-button"
@@ -544,8 +541,11 @@
                                     oncontextmenu={(event) => openObjectMenu(event, 'samples', availableSamples, item)}
                                     onkeydown={(event) => handleContainedKeyboard(event, 'samples', index, item)}
                                 >
-                                    <strong>{item.name}</strong>
-                                    {#if view === 'samples'}<small>{item.membershipLabel ?? 'Standalone'}</small>{/if}
+                                    <ObjectSizeIdentity
+                                        name={item.name}
+                                        object={item.object}
+                                        metadata={view === 'samples' ? (item.membershipLabel ?? 'Standalone') : ''}
+                                    />
                                 </button>
                                 <button
                                     class="contained-playback icon-button"
diff --git a/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.test.ts b/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.test.ts
index 5084e550..f0847080 100644
--- a/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.test.ts
+++ b/apps/axkdeck/src/lib/components/ContainedObjectWorkspace.test.ts
@@ -21,6 +21,7 @@ function object(objectType: string, name: string): SamplerObject {
         categoryName: objectType,
         sfsId: 0,
         storedSizeBytes: 128,
+        sizeWithDependenciesBytes: null,
         sampleRate: 44_100,
         rootKey: 60,
         frameCount: 44_100,
@@ -118,6 +119,7 @@ describe('ContainedObjectWorkspace', () => {
 
     it('does not apply the standalone filter to Sample Bank members', () => {
         const bank = structure('SBAC', 'Brass');
+        bank.object.sizeWithDependenciesBytes = 2048;
         const member = structure('SBNK', 'Banked Brass');
         member.sampleBankObjectIds = [bank.objectId];
         member.membershipLabel = 'Sample Bank: Brass';
@@ -139,6 +141,8 @@ describe('ContainedObjectWorkspace', () => {
 
         expect(screen.queryByRole('checkbox', { name: 'Show only standalone' })).toBeNull();
         expect(screen.getByRole('button', { name: 'Inspect Banked Brass' })).toBeTruthy();
+        expect(screen.getByText('1 Sample · 128 B · 2 KiB incl. deps.')).toBeTruthy();
+        expect(document.querySelectorAll('[title*="Object size with deps.: 2 KiB"]')).toHaveLength(2);
     });
 
     it('navigates vertically within a lane and horizontally through the hierarchy', async () => {
diff --git a/apps/axkdeck/src/lib/components/CreateHardDiskImageDialog.svelte b/apps/axkdeck/src/lib/components/CreateHardDiskImageDialog.svelte
index 605608b3..47f0b02f 100644
--- a/apps/axkdeck/src/lib/components/CreateHardDiskImageDialog.svelte
+++ b/apps/axkdeck/src/lib/components/CreateHardDiskImageDialog.svelte
@@ -203,7 +203,7 @@
             {#if imageType === 'HD'}
                 <fieldset disabled={busy || loading}>
                     <legend>Capacity</legend>
-                    <div class="create-hds-segments capacity-segments">
+                    <div class="create-hds-segments capacity-segments dialog-segmented-control">
                         {#each profiles as profile (profile.profileId)}
                             <button
                                 type="button"
@@ -217,7 +217,7 @@
 
                 <fieldset disabled={busy || loading}>
                     <legend>Partitions</legend>
-                    <div class="create-hds-segments partition-segments">
+                    <div class="create-hds-segments partition-segments dialog-segmented-control">
                         {#each partitionCounts as count (count)}
                             {@const option = selectedProfile?.partitionOptions.find(
                                 (candidate) => candidate.partitionCount === count,
@@ -282,7 +282,7 @@
         display: grid;
         gap: 4px;
         color: var(--color-text-muted);
-        font-size: 9px;
+        font-size: var(--dialog-label-font-size);
     }
 
     .create-hds-field output,
@@ -298,7 +298,7 @@
         border-radius: 6px;
         background: var(--color-bg-deep);
         font-family: var(--font-mono);
-        font-size: 10px;
+        font-size: var(--dialog-control-font-size);
         text-overflow: ellipsis;
         white-space: nowrap;
     }
@@ -339,16 +339,11 @@
     legend {
         margin-bottom: 4px;
         color: var(--color-text-muted);
-        font-size: 9px;
+        font-size: var(--dialog-label-font-size);
     }
 
     .create-hds-segments {
-        display: grid;
-        gap: 1px;
-        overflow: hidden;
-        border: 1px solid var(--color-border);
-        border-radius: 6px;
-        background: var(--color-border);
+        grid-auto-flow: row;
     }
 
     .capacity-segments {
@@ -359,36 +354,10 @@
         grid-template-columns: repeat(8, minmax(0, 1fr));
     }
 
-    .create-hds-segments button {
-        min-width: 0;
-        height: 30px;
-        padding: 0 5px;
-        overflow: hidden;
-        color: var(--color-text);
-        border: 0;
-        background: var(--color-panel);
-        cursor: pointer;
-        font-size: 10px;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-    }
-
-    .create-hds-segments button[aria-pressed='true'] {
-        color: var(--color-text-strong);
-        background: var(--color-accent-strong);
-    }
-
-    .create-hds-segments button:disabled {
-        color: var(--color-text-dim);
-        background: var(--color-bg-deep);
-        cursor: default;
-        opacity: 0.55;
-    }
-
     .create-hds-summary {
         margin: 0;
         color: var(--color-text-muted);
-        font-size: 9px;
+        font-size: var(--dialog-metadata-font-size);
     }
 
     .create-hds-error {
@@ -398,7 +367,7 @@
         border: 1px solid rgb(190 80 80 / 35%);
         border-radius: 5px;
         background: rgb(120 35 35 / 20%);
-        font-size: 9px;
+        font-size: var(--dialog-body-font-size);
     }
 
     footer {
diff --git a/apps/axkdeck/src/lib/components/DialogVisualContract.test.ts b/apps/axkdeck/src/lib/components/DialogVisualContract.test.ts
new file mode 100644
index 00000000..f32e3cfb
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/DialogVisualContract.test.ts
@@ -0,0 +1,88 @@
+/// <reference types="node" />
+
+import { readdirSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+function source(path: string): string {
+    return readFileSync(resolve(process.cwd(), path), 'utf8');
+}
+
+const appStyles = source('src/app.css');
+const checkboxDialogs = [
+    'src/lib/components/MidiImportDialog.svelte',
+    'src/lib/components/ObjectDeletionDialog.svelte',
+    'src/lib/components/PackageBatchItemsTable.svelte',
+    'src/lib/components/ProgramGenerationDialog.svelte',
+    'src/lib/components/WaveDataCleanupDialog.svelte',
+    'src/lib/components/WorkspaceManager.svelte',
+];
+const segmentedControls = [
+    'src/lib/components/CreateHardDiskImageDialog.svelte',
+    'src/lib/components/ImportDestinationChooser.svelte',
+    'src/lib/components/PackageBatchDestinationChooser.svelte',
+    'src/lib/components/SfzExportDialog.svelte',
+];
+const componentDirectory = resolve(process.cwd(), 'src/lib/components');
+const dialogComponents = readdirSync(componentDirectory)
+    .filter((name) => name.endsWith('.svelte'))
+    .map((name) => `src/lib/components/${name}`)
+    .filter((path) => source(path).includes('role="dialog"'));
+
+describe('dialog visual contract', () => {
+    it('defines one compact typography scale for dialog content', () => {
+        expect(appStyles).toMatch(/--dialog-title-font-size:\s*13px/);
+        expect(appStyles).toMatch(/--dialog-body-font-size:\s*11px/);
+        expect(appStyles).toMatch(/--dialog-section-font-size:\s*11px/);
+        expect(appStyles).toMatch(/--dialog-table-header-font-size:\s*10px/);
+        expect(appStyles).toMatch(/--dialog-metadata-font-size:\s*10px/);
+        expect(appStyles).toMatch(/\.dialog-shell\s*\{[^}]*font-size:\s*var\(--dialog-body-font-size\)/s);
+
+        const sharedDialogStyles = appStyles.slice(
+            appStyles.indexOf('.dialog-shell {'),
+            appStyles.indexOf('.connection-mode {'),
+        );
+        expect(sharedDialogStyles).not.toMatch(/font-size:\s*\d+px/);
+        for (const path of dialogComponents) {
+            expect(source(path), path).not.toMatch(/font-size:\s*\d+px/);
+        }
+    });
+
+    it('uses the shared checkbox geometry in every dialog with checkbox selection', () => {
+        expect(appStyles).toMatch(/\.dialog-checkbox\s*\{[^}]*width:\s*14px[^}]*height:\s*14px/s);
+        expect(appStyles).toMatch(/\.dialog-checkbox::before\s*\{[^}]*width:\s*4px[^}]*height:\s*7px/s);
+        expect(appStyles).not.toContain('.deletion-checkbox');
+        for (const path of checkboxDialogs) {
+            const component = source(path);
+            expect(component, path).toContain('class="dialog-checkbox"');
+            expect(component, path).not.toContain('class="deletion-checkbox"');
+        }
+    });
+
+    it('uses the shared compact segmented-control treatment', () => {
+        expect(appStyles).toMatch(
+            /\.dialog-segmented-control\s*>\s*button\s*\{[^}]*min-height:\s*27px[^}]*font-size:\s*var\(--dialog-table-header-font-size\)/s,
+        );
+        expect(appStyles).toMatch(
+            /\.dialog-segmented-control\s*>\s*button:focus-visible\s*\{[^}]*outline-offset:\s*-2px/s,
+        );
+        for (const path of segmentedControls) {
+            expect(source(path), path).toContain('dialog-segmented-control');
+        }
+    });
+
+    it('keeps dense dialog table headings and metadata on the compact scale', () => {
+        const programs = source('src/lib/components/ProgramGenerationDialog.svelte');
+        const tx16w = source('src/lib/components/Tx16wImportDialog.svelte');
+        const companions = source('src/lib/components/CompanionDiskDialog.svelte');
+
+        expect(programs).toMatch(
+            /\.program-generation-header\s*\{[^}]*font-size:\s*var\(--dialog-table-header-font-size\)/s,
+        );
+        expect(tx16w).toMatch(/\.import-mode legend\s*\{[^}]*font-size:\s*var\(--dialog-label-font-size\)/s);
+        expect(tx16w).toMatch(/\.mapping-notice\s*\{[^}]*font-size:\s*var\(--dialog-body-font-size\)/s);
+        expect(companions).toMatch(
+            /\.companion-disk-content h3\s*\{[^}]*font-size:\s*var\(--dialog-section-font-size\)/s,
+        );
+    });
+});
diff --git a/apps/axkdeck/src/lib/components/ExperimentalWarningDialog.svelte b/apps/axkdeck/src/lib/components/ExperimentalWarningDialog.svelte
index 8b3062a9..874c3631 100644
--- a/apps/axkdeck/src/lib/components/ExperimentalWarningDialog.svelte
+++ b/apps/axkdeck/src/lib/components/ExperimentalWarningDialog.svelte
@@ -71,6 +71,6 @@
 
     .experimental-warning-disclaimer {
         color: var(--color-text-muted);
-        font-size: 10px;
+        font-size: var(--dialog-metadata-font-size);
     }
 </style>
diff --git a/apps/axkdeck/src/lib/components/ImageIntegrityDialog.svelte b/apps/axkdeck/src/lib/components/ImageIntegrityDialog.svelte
index bf81db32..216425b3 100644
--- a/apps/axkdeck/src/lib/components/ImageIntegrityDialog.svelte
+++ b/apps/axkdeck/src/lib/components/ImageIntegrityDialog.svelte
@@ -187,7 +187,7 @@
     .issue-severity,
     .issue-row small {
         color: var(--color-text-muted);
-        font-size: 10px;
+        font-size: var(--dialog-metadata-font-size);
     }
 
     .issue-row small {
diff --git a/apps/axkdeck/src/lib/components/ImageNavigator.svelte b/apps/axkdeck/src/lib/components/ImageNavigator.svelte
index 26844337..798d7e4a 100644
--- a/apps/axkdeck/src/lib/components/ImageNavigator.svelte
+++ b/apps/axkdeck/src/lib/components/ImageNavigator.svelte
@@ -1,5 +1,7 @@
 <script lang="ts">
     import type { ImageLocation } from '../storageLocations';
+    import type { ObjectSelectionMode } from '../objectSelection';
+    import { orderSamplerTreeItems } from '../samplerTreeOrder';
     import type { DiskTreeItem, ImageTreeAction } from '../types';
     import Icon from './Icon.svelte';
     import ImageTreeContextMenu from './ImageTreeContextMenu.svelte';
@@ -9,6 +11,7 @@
         image: ImageLocation | null;
         items: DiskTreeItem[];
         selectedId: string;
+        selectedVolumeIds?: readonly string[];
         opening: boolean;
         storageLocationsAvailable: boolean;
         onopen: () => void;
@@ -16,7 +19,8 @@
         onclose: () => void;
         onintegrity?: () => void;
         onmanagelocations: () => void;
-        onselect: (item: DiskTreeItem) => void;
+        onselect: (item: DiskTreeItem, mode: ObjectSelectionMode, visibleVolumes: readonly DiskTreeItem[]) => void;
+        oncontextselect?: (item: DiskTreeItem, visibleVolumes: readonly DiskTreeItem[]) => void;
         onloadchildren: (
             parentId: string,
             offset: number,
@@ -31,6 +35,7 @@
         audioExportEnabled?: boolean;
         mediaConversionEnabled?: boolean;
         allocationInspectionEnabled?: boolean;
+        samplerOrderingEnabled?: boolean;
         onimageaction: (item: DiskTreeItem, action: ImageTreeAction) => void;
     }
 
@@ -38,6 +43,7 @@
         image,
         items,
         selectedId,
+        selectedVolumeIds = [],
         opening,
         storageLocationsAvailable,
         onopen,
@@ -46,6 +52,7 @@
         onintegrity = () => undefined,
         onmanagelocations,
         onselect,
+        oncontextselect = (item, visibleVolumes) => onselect(item, 'replace', visibleVolumes),
         onloadchildren,
         volumeActionsEnabled,
         partitionActionsEnabled,
@@ -56,11 +63,19 @@
         audioExportEnabled = false,
         mediaConversionEnabled = false,
         allocationInspectionEnabled = false,
+        samplerOrderingEnabled = false,
         onimageaction,
     }: Props = $props();
     let filter = $state('');
     let imageMenuOpen = $state(false);
-    let treeMenu = $state<{ item: DiskTreeItem; left: number; top: number } | null>(null);
+    let treeMenu = $state<{
+        item: DiskTreeItem;
+        left: number;
+        top: number;
+        selectionCount: number;
+    } | null>(null);
+    let treeScroll = $state<HTMLElement>();
+    const registeredItems = new Map<string, DiskTreeItem>();
     let loadedRootChildren = $state<DiskTreeItem[]>([]);
     let rootLoadError = $state(false);
     let rootLoadGeneration = 0;
@@ -72,6 +87,9 @@
         if (items.length !== 1 || items[0]?.kind !== 'disk') return items;
         return items[0].children ?? loadedRootChildren;
     });
+    const orderedContentItems = $derived(
+        samplerOrderingEnabled ? orderSamplerTreeItems(contentItems, 'partition') : contentItems,
+    );
 
     $effect(() => {
         const root = items.length === 1 && items[0]?.kind === 'disk' ? items[0] : null;
@@ -108,11 +126,40 @@
 
     const visibleItems = $derived.by(() => {
         const query = filter.trim().toLocaleLowerCase();
-        return query ? contentItems.filter((item) => matches(item, query)) : contentItems;
+        return query ? orderedContentItems.filter((item) => matches(item, query)) : orderedContentItems;
     });
 
+    function registerTreeItem(item: DiskTreeItem, present: boolean): void {
+        if (present) registeredItems.set(item.id, item);
+        else if (registeredItems.get(item.id) === item) registeredItems.delete(item.id);
+    }
+
+    function visibleVolumes(): DiskTreeItem[] {
+        if (!treeScroll) return [];
+        return Array.from(
+            treeScroll.querySelectorAll<HTMLElement>('.tree-item-select[data-tree-kind="volume"]'),
+        ).flatMap((element) => {
+            const item = registeredItems.get(element.dataset.treeId ?? '');
+            return item?.kind === 'volume' ? [item] : [];
+        });
+    }
+
+    function selectTreeItem(item: DiskTreeItem, mode: ObjectSelectionMode): void {
+        onselect(item, mode, visibleVolumes());
+    }
+
     function requestTreeMenu(item: DiskTreeItem, x: number, y: number): void {
-        treeMenu = { item, left: x, top: y };
+        const selected = item.kind === 'volume' && selectedVolumeIds.includes(item.id);
+        const volumes = visibleVolumes();
+        if (selected) oncontextselect(item, volumes);
+        else onselect(item, 'replace', volumes);
+        if (selected && selectedVolumeIds.length > 1 && !volumeActionsEnabled) return;
+        treeMenu = {
+            item,
+            left: x,
+            top: y,
+            selectionCount: selected ? selectedVolumeIds.length : 1,
+        };
     }
 
     function chooseTreeAction(action: ImageTreeAction): void {
@@ -257,16 +304,20 @@
         {/if}
 
         <div
+            bind:this={treeScroll}
             class="image-tree-scroll min-h-0 flex-1 overflow-y-auto px-2 pb-4"
             class:context-menu-open={treeMenu !== null}
             aria-label="Image contents tree"
+            data-multiselectable="true"
         >
             {#if image}
                 {#each visibleItems as item (item.id)}
                     <TreeNode
                         {item}
                         {selectedId}
-                        {onselect}
+                        {selectedVolumeIds}
+                        onselect={selectTreeItem}
+                        onregister={registerTreeItem}
                         {onloadchildren}
                         {volumeActionsEnabled}
                         {partitionActionsEnabled}
@@ -277,6 +328,7 @@
                         {audioExportEnabled}
                         {mediaConversionEnabled}
                         {allocationInspectionEnabled}
+                        {samplerOrderingEnabled}
                         onrequestmenu={requestTreeMenu}
                     />
                 {:else}
@@ -314,6 +366,7 @@
             item={treeMenu.item}
             left={treeMenu.left}
             top={treeMenu.top}
+            selectionCount={treeMenu.selectionCount}
             {volumeActionsEnabled}
             {partitionActionsEnabled}
             {packageImportEnabled}
diff --git a/apps/axkdeck/src/lib/components/ImageNavigator.test.ts b/apps/axkdeck/src/lib/components/ImageNavigator.test.ts
index 34d5764b..84141e84 100644
--- a/apps/axkdeck/src/lib/components/ImageNavigator.test.ts
+++ b/apps/axkdeck/src/lib/components/ImageNavigator.test.ts
@@ -139,6 +139,60 @@ describe('ImageNavigator', () => {
         expect(screen.getByRole('searchbox', { name: 'Search image contents' })).toBeTruthy();
     });
 
+    it('renders SFS partitions in sampler display order and preserves physical selection identity', async () => {
+        const onselect = vi.fn();
+        const { container } = render(ImageNavigator, {
+            props: {
+                ...common,
+                image: serverFileLocation({ rootId: 'workspace', relativePath: 'disk.hds' }),
+                samplerOrderingEnabled: true,
+                onselect,
+                items: [
+                    {
+                        id: 'disk',
+                        name: 'disk.hds',
+                        kind: 'disk',
+                        childCount: 4,
+                        children: [
+                            { id: 'p0', name: '001_PARTITION 1', kind: 'partition', partitionIndex: 0, childCount: 0 },
+                            { id: 'p2', name: 'A_PARTITION 3', kind: 'partition', partitionIndex: 2, childCount: 0 },
+                            { id: 'p3', name: '_PARTITION 4', kind: 'partition', partitionIndex: 3, childCount: 0 },
+                            { id: 'p7', name: '$PARTITION 8', kind: 'partition', partitionIndex: 7, childCount: 0 },
+                        ],
+                    },
+                ],
+            },
+        });
+
+        expect([...container.querySelectorAll('.tree-item-name')].map((name) => name.textContent)).toEqual([
+            '$PARTITION 8',
+            '001_PARTITION 1',
+            'A_PARTITION 3',
+            '_PARTITION 4',
+        ]);
+
+        await fireEvent.click(screen.getByRole('button', { name: '$PARTITION 8 [Partition 7]' }));
+        expect(onselect).toHaveBeenCalledWith(expect.objectContaining({ id: 'p7', partitionIndex: 7 }), 'replace', []);
+    });
+
+    it('does not reorder partitions when sampler ordering is disabled', () => {
+        const { container } = render(ImageNavigator, {
+            props: {
+                ...common,
+                image: serverFileLocation({ rootId: 'workspace', relativePath: 'library.iso' }),
+                items: [
+                    { id: 'p3', name: '_PARTITION 4', kind: 'partition', partitionIndex: 3, childCount: 0 },
+                    { id: 'p7', name: '$PARTITION 8', kind: 'partition', partitionIndex: 7, childCount: 0 },
+                ],
+            },
+        });
+
+        expect([...container.querySelectorAll('.tree-item-name')].map((name) => name.textContent)).toEqual([
+            '_PARTITION 4',
+            '$PARTITION 8',
+        ]);
+    });
+
     it('preserves sampler-significant repeated spaces in volume names', () => {
         const { container } = render(ImageNavigator, {
             props: {
@@ -221,18 +275,67 @@ describe('ImageNavigator', () => {
             clientX: 20,
             clientY: 20,
         });
-        await fireEvent.click(screen.getByRole('menuitem', { name: 'Import package…' }));
-        expect(onimageaction).toHaveBeenCalledWith(expect.objectContaining({ id: 'volume' }), 'import-package');
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Import' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Import packages…' }));
+        expect(onimageaction).toHaveBeenCalledWith(expect.objectContaining({ id: 'volume' }), 'import-packages');
 
         await fireEvent.contextMenu(screen.getByRole('button', { name: /DRUMS/ }), {
             clientX: 20,
             clientY: 20,
         });
-        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export package…' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export volume package…' }));
         expect(onimageaction).toHaveBeenCalledWith(expect.objectContaining({ id: 'volume' }), 'export-package');
         expect(screen.queryByRole('menuitem', { name: 'Delete volume' })).toBeNull();
     });
 
+    it('groups volume workflows and expert tools with consistent ordering and separators', async () => {
+        const onimageaction = vi.fn();
+        render(ImageNavigator, {
+            props: {
+                ...common,
+                image: serverFileLocation({ rootId: 'workspace', relativePath: 'disk.hds' }),
+                items: [
+                    {
+                        id: 'volume',
+                        name: 'DRUMS',
+                        kind: 'volume',
+                        childCount: 0,
+                        partitionIndex: 0,
+                        volumeDirectoryId: 17,
+                    },
+                ],
+                packageImportEnabled: true,
+                packageExportEnabled: true,
+                audioExportEnabled: true,
+                mediaConversionEnabled: true,
+                volumeActionsEnabled: true,
+                onimageaction,
+            },
+        });
+
+        await fireEvent.contextMenu(screen.getByRole('button', { name: /DRUMS/ }));
+        const rootMenu = screen.getByRole('menu', { name: 'DRUMS actions' });
+        expect(
+            within(rootMenu)
+                .getAllByRole('menuitem')
+                .map((item) => item.textContent?.trim()),
+        ).toEqual(['Import', 'Export', 'Rename volume…', 'Delete volume', 'Expert']);
+        expect(rootMenu.querySelectorAll(':scope > [role="separator"]')).toHaveLength(2);
+
+        await fireEvent.click(within(rootMenu).getByRole('menuitem', { name: 'Export' }));
+        const exportMenu = screen.getByRole('menu', { name: 'Export actions' });
+        expect(
+            within(exportMenu)
+                .getAllByRole('menuitem')
+                .map((item) => item.textContent?.trim()),
+        ).toEqual(['Export volume package…', 'Export floppy image…', 'Export SFZ…']);
+
+        await fireEvent.click(within(rootMenu).getByRole('menuitem', { name: 'Expert' }));
+        const expertMenu = screen.getByRole('menu', { name: 'Expert actions' });
+        expect(within(expertMenu).getByRole('menuitem', { name: 'Repair object placement…' })).toBeTruthy();
+    });
+
     it('offers only volume package export for a read-only AXK object directory', async () => {
         const onimageaction = vi.fn();
         render(ImageNavigator, {
@@ -265,10 +368,11 @@ describe('ImageNavigator', () => {
         });
 
         await fireEvent.contextMenu(screen.getByRole('button', { name: /Object directory/ }));
-        expect(screen.queryByRole('menuitem', { name: 'Import package…' })).toBeNull();
+        expect(screen.queryByRole('menuitem', { name: 'Import' })).toBeNull();
         expect(screen.queryByRole('menuitem', { name: 'Rename volume…' })).toBeNull();
         expect(screen.queryByRole('menuitem', { name: 'Delete volume' })).toBeNull();
-        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export package…' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export volume package…' }));
         expect(onimageaction).toHaveBeenCalledWith(
             expect.objectContaining({ id: 'object-directory-volume', partitionIndex: 0 }),
             'export-package',
@@ -312,14 +416,7 @@ describe('ImageNavigator', () => {
             within(rootMenu)
                 .getAllByRole('menuitem')
                 .map((item) => item.textContent?.trim()),
-        ).toEqual([
-            'Import',
-            'Export',
-            'Rename partition…',
-            'Add volume…',
-            'Visualize partition allocation',
-            'Repair object placement…',
-        ]);
+        ).toEqual(['Import', 'Export', 'Rename partition…', 'Add volume…', 'Expert']);
         expect(rootMenu.querySelectorAll(':scope > [role="separator"]')).toHaveLength(2);
         const menuGeometry = appStyles.match(/\.tree-context-menu\s*\{[^}]+\}/)?.[0];
         const menuActionGeometry = appStyles.match(/\.tree-context-menu button\s*\{[^}]+\}/)?.[0];
@@ -353,7 +450,14 @@ describe('ImageNavigator', () => {
         expect(treeScroll?.classList.contains('context-menu-open')).toBe(false);
         expect(onimageaction).toHaveBeenCalledWith(expect.objectContaining({ id: 'partition-0' }), 'import-packages');
         await fireEvent.contextMenu(partitionButton!);
-        await fireEvent.click(screen.getByRole('menuitem', { name: 'Visualize partition allocation' }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Expert' }));
+        const expertMenu = screen.getByRole('menu', { name: 'Expert actions' });
+        expect(
+            within(expertMenu)
+                .getAllByRole('menuitem')
+                .map((item) => item.textContent?.trim()),
+        ).toEqual(['Visualize partition allocation', 'Repair object placement…']);
+        await fireEvent.click(within(expertMenu).getByRole('menuitem', { name: 'Visualize partition allocation' }));
         expect(onimageaction).toHaveBeenCalledWith(
             expect.objectContaining({ id: 'partition-0' }),
             'inspect-allocation',
@@ -386,6 +490,7 @@ describe('ImageNavigator', () => {
                 packageImportEnabled: true,
                 volumePackageExportEnabled: true,
                 volumeFloppyExportEnabled: true,
+                allocationInspectionEnabled: true,
                 onimageaction,
             },
         });
@@ -400,7 +505,16 @@ describe('ImageNavigator', () => {
         expect(document.activeElement).toBe(importParent);
         expect(screen.queryByRole('menu', { name: 'Import actions' })).toBeNull();
         await fireEvent.keyDown(importParent, { key: 'ArrowDown' });
-        expect(document.activeElement).toBe(screen.getByRole('menuitem', { name: 'Export' }));
+        const exportParent = screen.getByRole('menuitem', { name: 'Export' });
+        expect(document.activeElement).toBe(exportParent);
+        await fireEvent.keyDown(exportParent, { key: 'End' });
+        const expertParent = screen.getByRole('menuitem', { name: 'Expert' });
+        expect(document.activeElement).toBe(expertParent);
+        await fireEvent.keyDown(expertParent, { key: 'ArrowRight' });
+        const expertLeaf = screen.getByRole('menuitem', { name: 'Visualize partition allocation' });
+        expect(document.activeElement).toBe(expertLeaf);
+        await fireEvent.keyDown(expertLeaf, { key: 'ArrowLeft' });
+        expect(document.activeElement).toBe(expertParent);
     });
 
     it('does not render empty partition workflow submenus', async () => {
@@ -472,6 +586,7 @@ describe('ImageNavigator', () => {
 
         await fireEvent.click(screen.getByRole('button', { name: /Expand PARTITION 1/ }));
         await fireEvent.contextMenu(screen.getByRole('button', { name: /DRUMS/ }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Export' }));
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Export floppy image…' }));
         expect(onimageaction).toHaveBeenCalledWith(
             expect.objectContaining({ id: 'volume', volumeDirectoryId: 17 }),
@@ -510,12 +625,104 @@ describe('ImageNavigator', () => {
         });
 
         await fireEvent.contextMenu(screen.getByText('PARTITION 1').closest('button')!);
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Expert' }));
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Repair object placement…' }));
         expect(onimageaction).toHaveBeenCalledWith(expect.objectContaining({ id: 'partition' }), 'repair-placement');
 
         await fireEvent.click(screen.getByRole('button', { name: /Expand PARTITION 1/ }));
         await fireEvent.contextMenu(screen.getByRole('button', { name: /DRUMS/ }));
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Expert' }));
         await fireEvent.click(screen.getByRole('menuitem', { name: 'Repair object placement…' }));
         expect(onimageaction).toHaveBeenCalledWith(expect.objectContaining({ id: 'volume' }), 'repair-placement');
     });
+
+    it('preserves a selected volume set for context deletion and replaces it for an unselected row', async () => {
+        const onselect = vi.fn();
+        const oncontextselect = vi.fn();
+        const onimageaction = vi.fn();
+        render(ImageNavigator, {
+            props: {
+                ...common,
+                image: serverFileLocation({ rootId: 'workspace', relativePath: 'disk.hds' }),
+                selectedId: 'v1',
+                selectedVolumeIds: ['v0', 'v1'],
+                items: [
+                    {
+                        id: 'partition',
+                        name: 'PARTITION 1',
+                        kind: 'partition',
+                        partitionIndex: 0,
+                        childCount: 3,
+                        children: [
+                            { id: 'v0', name: 'Piano', kind: 'volume', partitionIndex: 0, childCount: 0 },
+                            { id: 'v1', name: 'Strings', kind: 'volume', partitionIndex: 0, childCount: 0 },
+                            { id: 'v2', name: 'Brass', kind: 'volume', partitionIndex: 0, childCount: 0 },
+                        ],
+                    },
+                ],
+                samplerOrderingEnabled: true,
+                volumeActionsEnabled: true,
+                onselect,
+                oncontextselect,
+                onimageaction,
+            },
+        });
+
+        const piano = await screen.findByRole('button', { name: 'Piano [Volume]' });
+        const strings = screen.getByRole('button', { name: 'Strings [Volume]' });
+        const brass = screen.getByRole('button', { name: 'Brass [Volume]' });
+        expect(piano.getAttribute('aria-pressed')).toBe('true');
+        expect(strings.getAttribute('aria-pressed')).toBe('true');
+        expect(brass.getAttribute('aria-pressed')).toBe('false');
+
+        await fireEvent.contextMenu(piano, { clientX: 40, clientY: 60 });
+        expect(oncontextselect).toHaveBeenCalledWith(
+            expect.objectContaining({ id: 'v0' }),
+            expect.arrayContaining([
+                expect.objectContaining({ id: 'v0' }),
+                expect.objectContaining({ id: 'v1' }),
+                expect.objectContaining({ id: 'v2' }),
+            ]),
+        );
+        expect(screen.getAllByRole('menuitem')).toHaveLength(1);
+        await fireEvent.click(screen.getByRole('menuitem', { name: 'Delete 2 volumes…' }));
+        expect(onimageaction).toHaveBeenCalledWith(expect.objectContaining({ id: 'v0' }), 'delete-volume');
+
+        await fireEvent.contextMenu(brass, { clientX: 50, clientY: 70 });
+        expect(onselect).toHaveBeenLastCalledWith(
+            expect.objectContaining({ id: 'v2' }),
+            'replace',
+            expect.arrayContaining([
+                expect.objectContaining({ id: 'v0' }),
+                expect.objectContaining({ id: 'v1' }),
+                expect.objectContaining({ id: 'v2' }),
+            ]),
+        );
+        expect(screen.queryByRole('menuitem', { name: 'Delete 2 volumes…' })).toBeNull();
+        expect(screen.getByRole('menuitem', { name: 'Rename volume…' })).toBeTruthy();
+    });
+
+    it('does not advertise deletion for a multi-selection on read-only media', async () => {
+        const oncontextselect = vi.fn();
+        render(ImageNavigator, {
+            props: {
+                ...common,
+                image: serverFileLocation({ rootId: 'workspace', relativePath: 'library.iso' }),
+                selectedId: 'v1',
+                selectedVolumeIds: ['v0', 'v1'],
+                items: [
+                    { id: 'v0', name: 'Piano', kind: 'volume', partitionIndex: 0, childCount: 0 },
+                    { id: 'v1', name: 'Strings', kind: 'volume', partitionIndex: 0, childCount: 0 },
+                ],
+                packageExportEnabled: true,
+                oncontextselect,
+            },
+        });
+
+        await fireEvent.contextMenu(screen.getByRole('button', { name: 'Piano [Volume]' }));
+
+        expect(oncontextselect).toHaveBeenCalledOnce();
+        expect(screen.queryByRole('menu')).toBeNull();
+        expect(screen.queryByRole('menuitem', { name: /Delete/ })).toBeNull();
+    });
 });
diff --git a/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte
index 86435cde..8c114ccd 100644
--- a/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte
+++ b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.svelte
@@ -7,6 +7,7 @@
         item: DiskTreeItem;
         left: number;
         top: number;
+        selectionCount?: number;
         volumeActionsEnabled: boolean;
         partitionActionsEnabled: boolean;
         packageImportEnabled: boolean;
@@ -20,12 +21,13 @@
         onclose: () => void;
     }
 
-    type Submenu = 'import' | 'export';
+    type Submenu = 'import' | 'export' | 'expert';
 
     let {
         item,
         left,
         top,
+        selectionCount = 1,
         volumeActionsEnabled,
         partitionActionsEnabled,
         packageImportEnabled,
@@ -42,6 +44,7 @@
     let submenuMenu = $state<HTMLDivElement>();
     let importParent = $state<HTMLButtonElement>();
     let exportParent = $state<HTMLButtonElement>();
+    let expertParent = $state<HTMLButtonElement>();
     let rootLeft = $state(0);
     let rootTop = $state(0);
     let submenuLeft = $state(0);
@@ -64,6 +67,16 @@
     const partitionHasTools = $derived(
         item.kind === 'partition' && (allocationInspectionEnabled || partitionActionsEnabled),
     );
+    const volumeHasImport = $derived(item.kind === 'volume' && packageImportEnabled);
+    const volumeHasExport = $derived(
+        item.kind === 'volume' &&
+            (packageExportEnabled ||
+                audioExportEnabled ||
+                (mediaConversionEnabled && item.volumeDirectoryId !== undefined)),
+    );
+    const volumeHasMutation = $derived(item.kind === 'volume' && volumeActionsEnabled);
+    const volumeHasTools = $derived(item.kind === 'volume' && volumeActionsEnabled);
+    const multiVolumeSelection = $derived(item.kind === 'volume' && selectionCount > 1 && volumeActionsEnabled);
 
     function directMenuItems(menu: HTMLDivElement | undefined): HTMLButtonElement[] {
         if (!menu) return [];
@@ -103,7 +116,15 @@
     }
 
     function submenuParent(kind: Submenu): HTMLButtonElement | undefined {
-        return kind === 'import' ? importParent : exportParent;
+        if (kind === 'import') return importParent;
+        if (kind === 'export') return exportParent;
+        return expertParent;
+    }
+
+    function submenuLabel(kind: Submenu): string {
+        if (kind === 'import') return 'Import';
+        if (kind === 'export') return 'Export';
+        return 'Expert';
     }
 
     function openSubmenu(kind: Submenu, focusFirst: boolean): void {
@@ -217,7 +238,11 @@
     onclick={(event) => event.stopPropagation()}
     onkeydown={handleRootKey}
 >
-    {#if item.kind === 'partition'}
+    {#if multiVolumeSelection}
+        <button class="danger-menu-item" type="button" role="menuitem" onclick={() => choose('delete-volume')}
+            >Delete {selectionCount} volumes…</button
+        >
+    {:else if item.kind === 'partition'}
         {#if partitionHasImport}
             <button
                 bind:this={importParent}
@@ -270,46 +295,87 @@
         {#if partitionHasMutation && partitionHasTools}
             <div class="context-menu-separator" role="separator"></div>
         {/if}
-        {#if allocationInspectionEnabled}
+        {#if partitionHasTools}
             <button
+                bind:this={expertParent}
+                class="context-submenu-trigger"
                 type="button"
                 role="menuitem"
-                onmouseenter={() => closeSubmenu(false)}
-                onclick={() => choose('inspect-allocation')}>Visualize partition allocation</button
+                aria-haspopup="menu"
+                aria-expanded={activeSubmenu === 'expert'}
+                data-submenu="expert"
+                onmouseenter={() => openSubmenu('expert', false)}
+                onclick={() => openSubmenu('expert', true)}
             >
+                <span>Expert</span><Icon name="chevron" size={13} />
+            </button>
         {/if}
-        {#if partitionActionsEnabled}
+    {:else}
+        {#if volumeHasImport}
             <button
+                bind:this={importParent}
+                class="context-submenu-trigger"
                 type="button"
                 role="menuitem"
-                onmouseenter={() => closeSubmenu(false)}
-                onclick={() => choose('repair-placement')}>Repair object placement…</button
+                aria-haspopup="menu"
+                aria-expanded={activeSubmenu === 'import'}
+                data-submenu="import"
+                onmouseenter={() => openSubmenu('import', false)}
+                onclick={() => openSubmenu('import', true)}
             >
+                <span>Import</span><Icon name="chevron" size={13} />
+            </button>
         {/if}
-    {:else}
-        {#if packageImportEnabled}
-            <button type="button" role="menuitem" onclick={() => choose('import-package')}>Import package…</button>
+        {#if volumeHasExport}
+            <button
+                bind:this={exportParent}
+                class="context-submenu-trigger"
+                type="button"
+                role="menuitem"
+                aria-haspopup="menu"
+                aria-expanded={activeSubmenu === 'export'}
+                data-submenu="export"
+                onmouseenter={() => openSubmenu('export', false)}
+                onclick={() => openSubmenu('export', true)}
+            >
+                <span>Export</span><Icon name="chevron" size={13} />
+            </button>
         {/if}
-        {#if packageExportEnabled}
-            <button type="button" role="menuitem" onclick={() => choose('export-package')}>Export package…</button>
+        {#if (volumeHasImport || volumeHasExport) && (volumeHasMutation || volumeHasTools)}
+            <div class="context-menu-separator" role="separator"></div>
         {/if}
-        {#if audioExportEnabled}
-            <button type="button" role="menuitem" onclick={() => choose('export-sfz')}>Export SFZ…</button>
+        {#if volumeHasMutation}
+            <button
+                type="button"
+                role="menuitem"
+                onmouseenter={() => closeSubmenu(false)}
+                onclick={() => choose('rename-volume')}>Rename volume…</button
+            >
+            <button
+                class="danger-menu-item"
+                type="button"
+                role="menuitem"
+                onmouseenter={() => closeSubmenu(false)}
+                onclick={() => choose('delete-volume')}>Delete volume</button
+            >
         {/if}
-        {#if mediaConversionEnabled && item.volumeDirectoryId !== undefined}
-            <button type="button" role="menuitem" onclick={() => choose('export-floppy')}>Export floppy image…</button>
+        {#if volumeHasMutation && volumeHasTools}
+            <div class="context-menu-separator" role="separator"></div>
         {/if}
-        {#if volumeActionsEnabled}
-            {#if packageImportEnabled || packageExportEnabled || audioExportEnabled || mediaConversionEnabled}
-                <div class="context-menu-separator" role="separator"></div>
-            {/if}
-            <button type="button" role="menuitem" onclick={() => choose('repair-placement')}
-                >Repair object placement…</button
-            >
-            <button type="button" role="menuitem" onclick={() => choose('rename-volume')}>Rename volume…</button>
-            <button class="danger-menu-item" type="button" role="menuitem" onclick={() => choose('delete-volume')}
-                >Delete volume</button
+        {#if volumeHasTools}
+            <button
+                bind:this={expertParent}
+                class="context-submenu-trigger"
+                type="button"
+                role="menuitem"
+                aria-haspopup="menu"
+                aria-expanded={activeSubmenu === 'expert'}
+                data-submenu="expert"
+                onmouseenter={() => openSubmenu('expert', false)}
+                onclick={() => openSubmenu('expert', true)}
             >
+                <span>Expert</span><Icon name="chevron" size={13} />
+            </button>
         {/if}
     {/if}
 </div>
@@ -319,7 +385,7 @@
         bind:this={submenuMenu}
         class="tree-context-menu tree-context-submenu"
         role="menu"
-        aria-label={`${activeSubmenu === 'import' ? 'Import' : 'Export'} actions`}
+        aria-label={`${submenuLabel(activeSubmenu)} actions`}
         tabindex="-1"
         style={`left: ${submenuLeft}px; top: ${submenuTop}px; visibility: ${submenuPositioned ? 'visible' : 'hidden'}; pointer-events: ${submenuPositioned ? 'auto' : 'none'};`}
         onclick={(event) => event.stopPropagation()}
@@ -327,22 +393,53 @@
     >
         {#if activeSubmenu === 'import'}
             <button type="button" role="menuitem" onclick={() => choose('import-packages')}>Import packages…</button>
-        {:else}
-            {#if volumePackageExportEnabled}
-                <button type="button" role="menuitem" onclick={() => choose('export-volume-packages')}
-                    >Export volume packages…</button
-                >
+        {:else if activeSubmenu === 'export'}
+            {#if item.kind === 'partition'}
+                {#if volumePackageExportEnabled}
+                    <button type="button" role="menuitem" onclick={() => choose('export-volume-packages')}
+                        >Export volume packages…</button
+                    >
+                {/if}
+                {#if volumeFloppyExportEnabled}
+                    <button type="button" role="menuitem" onclick={() => choose('export-volume-floppies')}
+                        >Export volumes to floppies…</button
+                    >
+                {/if}
+                {#if mediaConversionEnabled}
+                    <button type="button" role="menuitem" onclick={() => choose('export-cdrom')}
+                        >Export CD-ROM image…</button
+                    >
+                {/if}
+            {:else}
+                {#if packageExportEnabled}
+                    <button type="button" role="menuitem" onclick={() => choose('export-package')}
+                        >Export volume package…</button
+                    >
+                {/if}
+                {#if mediaConversionEnabled && item.volumeDirectoryId !== undefined}
+                    <button type="button" role="menuitem" onclick={() => choose('export-floppy')}
+                        >Export floppy image…</button
+                    >
+                {/if}
+                {#if audioExportEnabled}
+                    <button type="button" role="menuitem" onclick={() => choose('export-sfz')}>Export SFZ…</button>
+                {/if}
             {/if}
-            {#if volumeFloppyExportEnabled}
-                <button type="button" role="menuitem" onclick={() => choose('export-volume-floppies')}
-                    >Export volumes to floppies…</button
+        {:else if item.kind === 'partition'}
+            {#if allocationInspectionEnabled}
+                <button type="button" role="menuitem" onclick={() => choose('inspect-allocation')}
+                    >Visualize partition allocation</button
                 >
             {/if}
-            {#if mediaConversionEnabled}
-                <button type="button" role="menuitem" onclick={() => choose('export-cdrom')}
-                    >Export CD-ROM image…</button
+            {#if partitionActionsEnabled}
+                <button type="button" role="menuitem" onclick={() => choose('repair-placement')}
+                    >Repair object placement…</button
                 >
             {/if}
+        {:else}
+            <button type="button" role="menuitem" onclick={() => choose('repair-placement')}
+                >Repair object placement…</button
+            >
         {/if}
     </div>
 {/if}
diff --git a/apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts
index 4bb25e77..ecbdb9de 100644
--- a/apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts
+++ b/apps/axkdeck/src/lib/components/ImageTreeContextMenu.test.ts
@@ -10,6 +10,13 @@ const partition = {
     name: 'Partition 1',
 } as DiskTreeItem;
 
+const volume = {
+    id: 'volume-1',
+    kind: 'volume',
+    name: 'Strings',
+    partitionIndex: 0,
+} as DiskTreeItem;
+
 const common = {
     item: partition,
     left: 240,
@@ -56,4 +63,16 @@ describe('ImageTreeContextMenu', () => {
         expect(submenu.style.pointerEvents).toBe('auto');
         expect(submenu.style.left).not.toBe('0px');
     });
+
+    it('offers only one plural delete command for a volume multi-selection', async () => {
+        const onaction = vi.fn();
+        render(ImageTreeContextMenu, {
+            props: { ...common, item: volume, selectionCount: 3, onaction },
+        });
+
+        const action = screen.getByRole('menuitem', { name: 'Delete 3 volumes…' });
+        expect(screen.getAllByRole('menuitem')).toEqual([action]);
+        await fireEvent.click(action);
+        expect(onaction).toHaveBeenCalledWith('delete-volume');
+    });
 });
diff --git a/apps/axkdeck/src/lib/components/ImportDestinationChooser.svelte b/apps/axkdeck/src/lib/components/ImportDestinationChooser.svelte
index ec244c56..e24d2566 100644
--- a/apps/axkdeck/src/lib/components/ImportDestinationChooser.svelte
+++ b/apps/axkdeck/src/lib/components/ImportDestinationChooser.svelte
@@ -37,10 +37,15 @@
     let listOpen = $state(false);
     let filtering = $state(false);
     let synchronizedSelection = $state('');
+    let synchronizedPartition = $state<number | null>(null);
+    let synchronizedMode = $state<ImportDestinationMode>('existing');
     let volumeInput = $state<HTMLInputElement>();
     const normalizedQuery = $derived(query.trim().toLocaleLowerCase());
+    const partitionVolumes = $derived(volumes.filter((option) => option.partitionIndex === partitionIndex));
     const filteredVolumes = $derived(
-        filtering ? volumes.filter((option) => option.label.toLocaleLowerCase().includes(normalizedQuery)) : volumes,
+        filtering
+            ? partitionVolumes.filter((option) => option.volumeName.toLocaleLowerCase().includes(normalizedQuery))
+            : partitionVolumes,
     );
     const selectedVolume = $derived(
         volumes.find((option) => option.partitionIndex === partitionIndex && option.volumeName === volumeName),
@@ -48,12 +53,21 @@
 
     $effect(() => {
         const nextSelection = selectedVolume ? volumeKey(selectedVolume) : '';
-        if (nextSelection && nextSelection !== synchronizedSelection && selectedVolume) {
-            query = selectedVolume.label;
+        const partitionChanged = partitionIndex !== synchronizedPartition;
+        const modeChanged = mode !== synchronizedMode;
+        if (selectedVolume && (nextSelection !== synchronizedSelection || partitionChanged || modeChanged)) {
+            query = selectedVolume.volumeName;
             filtering = false;
-            activeIndex = Math.max(0, volumes.indexOf(selectedVolume));
+            activeIndex = Math.max(0, partitionVolumes.indexOf(selectedVolume));
+        } else if (partitionChanged || modeChanged) {
+            query = '';
+            filtering = false;
+            activeIndex = -1;
+            listOpen = false;
         }
         synchronizedSelection = nextSelection;
+        synchronizedPartition = partitionIndex;
+        synchronizedMode = mode;
     });
 
     function volumeKey(option: ImportVolumeOption): string {
@@ -66,7 +80,7 @@
 
     function selectVolume(option: ImportVolumeOption): void {
         if (disabled) return;
-        query = option.label;
+        query = option.volumeName;
         filtering = false;
         synchronizedSelection = volumeKey(option);
         listOpen = false;
@@ -78,11 +92,11 @@
         filtering = true;
         activeIndex = -1;
         listOpen = true;
-        onvolume(null, '');
+        onvolume(partitionIndex, '');
     }
 
     function openList(): void {
-        if (disabled || volumes.length === 0) return;
+        if (disabled || partitionVolumes.length === 0) return;
         if (selectedVolume) filtering = false;
         listOpen = true;
         activeIndex = selectedVolume ? filteredVolumes.indexOf(selectedVolume) : -1;
@@ -93,12 +107,21 @@
         query = '';
         filtering = false;
         activeIndex = -1;
-        listOpen = volumes.length > 0;
+        listOpen = partitionVolumes.length > 0;
         synchronizedSelection = selectedVolume ? volumeKey(selectedVolume) : '';
-        onvolume(null, '');
+        onvolume(partitionIndex, '');
         queueMicrotask(() => volumeInput?.focus());
     }
 
+    function changePartition(value: string): void {
+        if (disabled || value === '') return;
+        query = '';
+        filtering = false;
+        activeIndex = -1;
+        listOpen = false;
+        onpartition(Number(value));
+    }
+
     function handleKey(event: KeyboardEvent): void {
         if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
             event.preventDefault();
@@ -122,28 +145,33 @@
 </script>
 
 <section class="import-destination" aria-label="Import destination">
-    <div class="destination-heading">
-        <strong>Destination</strong>
-        <div class="destination-mode" role="group" aria-label="Destination type">
-            <button
-                type="button"
-                class:active={mode === 'existing'}
-                aria-pressed={mode === 'existing'}
-                disabled={disabled || volumes.length === 0}
-                onclick={() => onmode('existing')}>Existing volume</button
-            >
-            <button
-                type="button"
-                class:active={mode === 'create'}
-                aria-pressed={mode === 'create'}
-                {disabled}
-                onclick={() => onmode('create')}>New volume</button
-            >
-        </div>
+    <strong class="destination-label">Destination volume</strong>
+    <div class="destination-mode dialog-segmented-control" role="group" aria-label="Destination volume type">
+        <button
+            type="button"
+            aria-pressed={mode === 'existing'}
+            disabled={disabled || volumes.length === 0}
+            onclick={() => onmode('existing')}>Existing</button
+        >
+        <button type="button" aria-pressed={mode === 'create'} {disabled} onclick={() => onmode('create')}>New</button>
     </div>
 
+    <select
+        class="destination-partition dialog-field-control"
+        aria-label="Destination partition"
+        value={partitionIndex ?? ''}
+        disabled={disabled || partitions.length === 0}
+        onchange={(event) => changePartition(event.currentTarget.value)}
+    >
+        {#if partitionIndex === null}
+            <option value="" disabled>Select partition</option>
+        {/if}
+        {#each partitions as option (option.partitionIndex)}
+            <option value={option.partitionIndex}>{option.name}</option>
+        {/each}
+    </select>
+
     {#if mode === 'existing'}
-        <label class="target-field" for="import-volume-search">Volume</label>
         <div class="volume-combobox">
             <input
                 bind:this={volumeInput}
@@ -151,15 +179,16 @@
                 class="dialog-field-control"
                 type="text"
                 role="combobox"
+                aria-label="Destination volume"
                 aria-autocomplete="list"
                 aria-expanded={listOpen}
                 aria-controls="import-volume-options"
                 aria-activedescendant={listOpen && filteredVolumes[activeIndex]
                     ? optionId(filteredVolumes[activeIndex])
                     : undefined}
-                placeholder="Select a volume"
+                placeholder={partitionVolumes.length === 0 ? 'No volumes in this partition' : 'Select a volume'}
                 value={query}
-                disabled={disabled || volumes.length === 0}
+                disabled={disabled || partitionIndex === null || partitionVolumes.length === 0}
                 autocomplete="off"
                 oninput={(event) => updateQuery(event.currentTarget.value)}
                 onfocus={openList}
@@ -194,7 +223,7 @@
                             onpointermove={() => (activeIndex = index)}
                             onclick={() => selectVolume(option)}
                         >
-                            {option.label}
+                            {option.volumeName}
                         </button>
                     {:else}
                         <p class="dialog-autocomplete-empty">No matching volumes</p>
@@ -203,97 +232,52 @@
             {/if}
         </div>
     {:else}
-        <div class="new-volume-fields">
-            <label class="target-field">
-                <span>Partition</span>
-                <select
-                    class="dialog-field-control"
-                    value={partitionIndex ?? ''}
-                    disabled={disabled || partitions.length === 0}
-                    onchange={(event) => onpartition(Number(event.currentTarget.value))}
-                >
-                    {#each partitions as option (option.partitionIndex)}
-                        <option value={option.partitionIndex}>{option.name}</option>
-                    {/each}
-                </select>
-            </label>
-            <label class="target-field">
-                <span>Volume name</span>
-                <input
-                    class="dialog-field-control"
-                    type="text"
-                    minlength="1"
-                    maxlength="16"
-                    value={volumeName}
-                    placeholder="Enter a volume name"
-                    {disabled}
-                    autocomplete="off"
-                    oninput={(event) => onname(event.currentTarget.value)}
-                />
-            </label>
-        </div>
+        <input
+            class="new-volume-name dialog-field-control"
+            type="text"
+            aria-label="New volume name"
+            minlength="1"
+            maxlength="16"
+            value={volumeName}
+            placeholder="Enter a volume name"
+            {disabled}
+            autocomplete="off"
+            oninput={(event) => onname(event.currentTarget.value)}
+        />
     {/if}
 </section>
 
 <style>
     .import-destination {
         display: grid;
-        gap: 9px;
-        margin-bottom: 12px;
+        grid-template-columns: max-content max-content minmax(140px, 0.35fr) minmax(0, 1fr);
+        align-items: center;
+        gap: 8px;
         padding: 10px;
         border: 1px solid var(--color-border);
         border-radius: 5px;
         background: rgb(255 255 255 / 2%);
     }
 
-    .destination-heading {
-        display: flex;
-        align-items: center;
-        justify-content: space-between;
-        gap: 12px;
-    }
-
-    .destination-heading > strong {
+    .destination-label {
         color: var(--color-text-strong);
-        font-size: 11px;
+        font-size: var(--dialog-section-font-size);
+        white-space: nowrap;
     }
 
     .destination-mode {
-        display: grid;
         grid-template-columns: repeat(2, minmax(0, 1fr));
-        overflow: hidden;
-        border: 1px solid var(--color-border);
-        border-radius: 4px;
-        background: var(--color-bg-deep);
     }
 
-    .destination-mode button {
-        min-height: 27px;
-        padding: 0 10px;
-        color: var(--color-text-muted);
-        border: 0;
-        border-right: 1px solid var(--color-border);
-        background: transparent;
-        cursor: pointer;
-        font-size: 10px;
-    }
-
-    .destination-mode button:last-child {
-        border-right: 0;
-    }
-
-    .destination-mode button.active {
-        color: #fff;
-        background: var(--color-accent-strong);
-    }
-
-    .destination-mode button:disabled {
-        cursor: default;
-        opacity: 0.45;
+    .destination-partition,
+    .new-volume-name {
+        min-width: 0;
+        width: 100%;
     }
 
     .volume-combobox {
         position: relative;
+        min-width: 0;
     }
 
     .volume-combobox > input {
@@ -335,33 +319,15 @@
         padding: 9px;
     }
 
-    .new-volume-fields {
-        display: grid;
-        grid-template-columns: minmax(140px, 0.7fr) minmax(180px, 1fr);
-        gap: 10px;
-    }
-
-    .target-field {
-        display: grid;
-        min-width: 0;
-        gap: 4px;
-        color: var(--color-text-muted);
-        font-size: var(--dialog-label-font-size);
-    }
-
-    .new-volume-fields :global(.dialog-field-control) {
-        min-width: 0;
-        width: 100%;
-    }
-
-    @media (max-width: 640px) {
-        .destination-heading,
-        .new-volume-fields {
-            grid-template-columns: 1fr;
+    @media (max-width: 760px) {
+        .import-destination {
+            grid-template-columns: minmax(0, 1fr) max-content;
         }
 
-        .destination-heading {
-            display: grid;
+        .destination-partition,
+        .volume-combobox,
+        .new-volume-name {
+            grid-column: 1 / -1;
         }
     }
 </style>
diff --git a/apps/axkdeck/src/lib/components/ImportDestinationChooser.test.ts b/apps/axkdeck/src/lib/components/ImportDestinationChooser.test.ts
index 669e0b09..d9820620 100644
--- a/apps/axkdeck/src/lib/components/ImportDestinationChooser.test.ts
+++ b/apps/axkdeck/src/lib/components/ImportDestinationChooser.test.ts
@@ -3,12 +3,16 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
-import { fireEvent, render, screen } from '@testing-library/svelte';
+import { fireEvent, render, screen, within } from '@testing-library/svelte';
 import { describe, expect, it, vi } from 'vitest';
 
 import ImportDestinationChooser from './ImportDestinationChooser.svelte';
 
 const appStyles = readFileSync(resolve(process.cwd(), 'src/app.css'), 'utf8');
+const destinationSource = readFileSync(
+    resolve(process.cwd(), 'src/lib/components/ImportDestinationChooser.svelte'),
+    'utf8',
+);
 
 const partitions = [
     { partitionIndex: 0, name: 'SOUNDS 01' },
@@ -38,30 +42,47 @@ function props(overrides: Record<string, unknown> = {}) {
 }
 
 describe('ImportDestinationChooser', () => {
-    it('preselects the exact volume and exposes every partition volume through an autocomplete', async () => {
+    it('uses one compact destination-volume row with concise mode labels', () => {
         render(ImportDestinationChooser, { props: props() });
 
-        const combobox = screen.getByRole('combobox', { name: 'Volume' }) as HTMLInputElement;
-        expect(combobox.value).toBe('SOUNDS 01 / Strings');
+        expect(screen.getByText('Destination volume')).toBeTruthy();
+        expect(screen.getByRole('button', { name: 'Existing' })).toBeTruthy();
+        expect(screen.getByRole('button', { name: 'New' })).toBeTruthy();
+        expect(screen.getByRole('combobox', { name: 'Destination partition' })).toBeTruthy();
+        expect(screen.getByRole('combobox', { name: 'Destination volume' })).toBeTruthy();
+        expect(destinationSource).toMatch(
+            /\.import-destination\s*\{[^}]*grid-template-columns:\s*max-content max-content minmax\([^;]+\) minmax\(0, 1fr\)/s,
+        );
+        const destinationRule = destinationSource.match(/\.import-destination\s*\{[^}]*\}/s)?.[0];
+        expect(destinationRule).not.toContain('margin-bottom');
+    });
+
+    it('preselects the exact volume and exposes only volumes from the selected partition', async () => {
+        render(ImportDestinationChooser, { props: props() });
+
+        const combobox = screen.getByRole('combobox', { name: 'Destination volume' }) as HTMLInputElement;
+        expect(combobox.value).toBe('Strings');
         await fireEvent.focus(combobox);
 
         expect(screen.getByRole('listbox', { name: 'Volumes' })).toBeTruthy();
-        expect(screen.getAllByRole('option')).toHaveLength(3);
-        expect(screen.getByRole('option', { name: /SOUNDS 02.*Pianos/ })).toBeTruthy();
+        const options = within(screen.getByRole('listbox', { name: 'Volumes' }));
+        expect(options.getAllByRole('option')).toHaveLength(2);
+        expect(options.getByRole('option', { name: 'Pianos' })).toBeTruthy();
+        expect(options.queryByRole('option', { name: /SOUNDS 02/ })).toBeNull();
     });
 
     it('filters volumes and selects an exact destination with the keyboard', async () => {
         const onvolume = vi.fn();
-        render(ImportDestinationChooser, { props: props({ partitionIndex: null, volumeName: '', onvolume }) });
+        render(ImportDestinationChooser, { props: props({ volumeName: '', onvolume }) });
 
-        const combobox = screen.getByRole('combobox', { name: 'Volume' });
-        await fireEvent.input(combobox, { target: { value: 'sounds 02' } });
-        expect(onvolume).toHaveBeenLastCalledWith(null, '');
-        expect(screen.getAllByRole('option')).toHaveLength(1);
+        const combobox = screen.getByRole('combobox', { name: 'Destination volume' });
+        await fireEvent.input(combobox, { target: { value: 'piano' } });
+        expect(onvolume).toHaveBeenLastCalledWith(0, '');
+        expect(within(screen.getByRole('listbox', { name: 'Volumes' })).getAllByRole('option')).toHaveLength(1);
         await fireEvent.keyDown(combobox, { key: 'ArrowDown' });
         await fireEvent.keyDown(combobox, { key: 'Enter' });
 
-        expect(onvolume).toHaveBeenLastCalledWith(1, 'Pianos');
+        expect(onvolume).toHaveBeenLastCalledWith(0, 'Pianos');
     });
 
     it('clears the selected volume, reopens all options, and retains keyboard focus', async () => {
@@ -70,11 +91,26 @@ describe('ImportDestinationChooser', () => {
 
         await fireEvent.click(screen.getByRole('button', { name: 'Clear volume' }));
 
-        const combobox = screen.getByRole('combobox', { name: 'Volume' }) as HTMLInputElement;
-        expect(onvolume).toHaveBeenLastCalledWith(null, '');
+        const combobox = screen.getByRole('combobox', { name: 'Destination volume' }) as HTMLInputElement;
+        expect(onvolume).toHaveBeenLastCalledWith(0, '');
         expect(combobox.value).toBe('');
         expect(document.activeElement).toBe(combobox);
-        expect(screen.getAllByRole('option')).toHaveLength(3);
+        expect(within(screen.getByRole('listbox', { name: 'Volumes' })).getAllByRole('option')).toHaveLength(2);
+    });
+
+    it('reports partition changes separately and disables volume selection for an empty partition', async () => {
+        const onpartition = vi.fn();
+        render(ImportDestinationChooser, {
+            props: props({ partitionIndex: 1, volumeName: '', volumes: volumes.slice(0, 2), onpartition }),
+        });
+
+        const partition = screen.getByRole('combobox', { name: 'Destination partition' });
+        await fireEvent.change(partition, { target: { value: '0' } });
+        expect(onpartition).toHaveBeenCalledWith(0);
+
+        const volume = screen.getByRole('combobox', { name: 'Destination volume' }) as HTMLInputElement;
+        expect(volume.disabled).toBe(true);
+        expect(volume.placeholder).toBe('No volumes in this partition');
     });
 
     it('uses the same dark dialog control treatment for a new volume name', async () => {
@@ -82,17 +118,19 @@ describe('ImportDestinationChooser', () => {
             props: props({ mode: 'create', partitionIndex: 0, volumeName: '' }),
         });
 
-        expect(screen.getByRole('textbox', { name: 'Volume name' }).classList).toContain('dialog-field-control');
-        expect(screen.getByRole('combobox', { name: 'Partition' }).classList).toContain('dialog-field-control');
+        expect(screen.getByRole('textbox', { name: 'New volume name' }).classList).toContain('dialog-field-control');
+        expect(screen.getByRole('combobox', { name: 'Destination partition' }).classList).toContain(
+            'dialog-field-control',
+        );
     });
 
     it('uses the shared compact dialog typography and dark autocomplete palette', async () => {
         render(ImportDestinationChooser, { props: props() });
 
-        const combobox = screen.getByRole('combobox', { name: 'Volume' });
+        const combobox = screen.getByRole('combobox', { name: 'Destination volume' });
         await fireEvent.focus(combobox);
         const listbox = screen.getByRole('listbox', { name: 'Volumes' });
-        const option = screen.getAllByRole('option')[0];
+        const option = within(listbox).getAllByRole('option')[0];
 
         expect(combobox.classList).toContain('dialog-field-control');
         expect(listbox.classList).toContain('dialog-autocomplete-list');
diff --git a/apps/axkdeck/src/lib/components/MidiImportDialog.svelte b/apps/axkdeck/src/lib/components/MidiImportDialog.svelte
index 4d97359b..d9db912b 100644
--- a/apps/axkdeck/src/lib/components/MidiImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/MidiImportDialog.svelte
@@ -299,6 +299,7 @@
                 <section class="system-exclusive-options" aria-label="System Exclusive import">
                     <label>
                         <input
+                            class="dialog-checkbox"
                             type="checkbox"
                             aria-label="Include SysEx events"
                             checked={includeSystemExclusive}
@@ -349,7 +350,7 @@
     .dialog-header p {
         margin: 2px 0 0;
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-metadata-font-size);
     }
     .midi-import-body {
         min-height: 0;
@@ -377,11 +378,11 @@
     .midi-import-head {
         color: var(--color-text-muted);
         border-bottom: 1px solid var(--color-border);
-        font-size: 9px;
+        font-size: var(--dialog-table-header-font-size);
     }
     .midi-import-row {
         border-bottom: 1px solid var(--color-border-subtle);
-        font-size: 10px;
+        font-size: var(--dialog-body-font-size);
     }
     .midi-import-row:last-of-type {
         border-bottom: 0;
@@ -400,7 +401,7 @@
         border-radius: 4px;
         background: var(--color-bg-deep);
         font-family: var(--font-mono);
-        font-size: 10px;
+        font-size: var(--dialog-control-font-size);
     }
     .midi-import-row span {
         color: var(--color-success);
@@ -413,7 +414,7 @@
     .midi-row-error {
         margin: 0;
         padding: 0 8px 6px;
-        font-size: 9px;
+        font-size: var(--dialog-metadata-font-size);
     }
     .system-exclusive-options {
         display: grid;
@@ -426,7 +427,7 @@
         display: flex;
         align-items: center;
         gap: 7px;
-        font-size: 10px;
+        font-size: var(--dialog-body-font-size);
     }
     .system-exclusive-options input {
         width: 14px;
@@ -436,6 +437,6 @@
     .system-exclusive-options p {
         margin: 0 0 0 21px;
         color: var(--color-text-muted);
-        font-size: 9px;
+        font-size: var(--dialog-metadata-font-size);
     }
 </style>
diff --git a/apps/axkdeck/src/lib/components/ObjectDeletionDialog.svelte b/apps/axkdeck/src/lib/components/ObjectDeletionDialog.svelte
index e2a3d198..c12c6cc7 100644
--- a/apps/axkdeck/src/lib/components/ObjectDeletionDialog.svelte
+++ b/apps/axkdeck/src/lib/components/ObjectDeletionDialog.svelte
@@ -14,14 +14,15 @@
         loading: boolean;
         busy: boolean;
         error: string;
-        onselectionchange: (objectId: string, selected: boolean) => void;
-        onselectall: (selected: boolean) => void;
+        onselectionchange: (role: 'REFERRER' | 'DEPENDENCY', objectId: string, selected: boolean) => void;
+        onselectall: (role: 'REFERRER' | 'DEPENDENCY', selected: boolean) => void;
         oncancel: () => void;
         onconfirm: () => void;
     }
 
     let { inspection, loading, busy, error, onselectionchange, onselectall, oncancel, onconfirm }: Props = $props();
-    let selectAllCheckbox = $state<HTMLInputElement>();
+    let selectAllReferrersCheckbox = $state<HTMLInputElement>();
+    let selectAllCleanupCheckbox = $state<HTMLInputElement>();
     const maximumDeletionObjects = 1024;
 
     const selectedIds = $derived(new Set(inspection?.selectedObjectIds ?? []));
@@ -29,25 +30,53 @@
     const targetImpacts = $derived(inspection?.impacts.filter((impact) => impact.role === 'TARGET') ?? []);
     const eligibleTargets = $derived(targetImpacts.filter((impact) => impact.status === 'REQUIRED'));
     const blockedTargets = $derived(targetImpacts.filter((impact) => impact.status === 'BLOCKED'));
+    const referenceBlockedTargets = $derived(
+        blockedTargets.filter((impact) => impact.reason === 'References must be resolved'),
+    );
+    const unsafeBlockedTargets = $derived(
+        blockedTargets.filter((impact) => impact.reason !== 'References must be resolved'),
+    );
+    const referrerImpacts = $derived(
+        inspection?.impacts.filter((impact) => impact.role === 'REFERRER' && impact.status === 'OPTIONAL') ?? [],
+    );
     const optionalImpacts = $derived(
         inspection?.impacts.filter((impact) => impact.role === 'DEPENDENCY' && impact.status === 'OPTIONAL') ?? [],
     );
     const retainedImpacts = $derived(
         inspection?.impacts.filter((impact) => impact.role === 'DEPENDENCY' && impact.status === 'PRESERVED') ?? [],
     );
-    const selectedOptionalCount = $derived(optionalImpacts.filter((impact) => selectedIds.has(impact.objectId)).length);
+    const requestedReferrerCount = $derived(referrerImpacts.filter((impact) => impact.requested).length);
+    const requestedCleanupCount = $derived(optionalImpacts.filter((impact) => impact.requested).length);
     const selectedObjectCount = $derived(inspection?.selectedObjectIds.length ?? 0);
+    const referrerCapacity = $derived(
+        Math.max(
+            0,
+            maximumDeletionObjects -
+                (inspection?.targetObjectIds.length ?? maximumDeletionObjects) -
+                (inspection?.cleanupObjectIds.length ?? 0),
+        ),
+    );
     const cleanupCapacity = $derived(
-        Math.max(0, maximumDeletionObjects - (inspection?.targetObjectIds.length ?? maximumDeletionObjects)),
+        Math.max(
+            0,
+            maximumDeletionObjects -
+                (inspection?.targetObjectIds.length ?? maximumDeletionObjects) -
+                (inspection?.referrerObjectIds.length ?? 0),
+        ),
     );
+    const selectableReferrerCount = $derived(Math.min(referrerImpacts.length, referrerCapacity));
     const selectableCleanupCount = $derived(Math.min(optionalImpacts.length, cleanupCapacity));
-    const allOptionalSelected = $derived(
-        selectableCleanupCount > 0 && selectedOptionalCount === selectableCleanupCount,
+    const allReferrersRequested = $derived(
+        selectableReferrerCount > 0 && requestedReferrerCount === selectableReferrerCount,
+    );
+    const someReferrersRequested = $derived(requestedReferrerCount > 0 && !allReferrersRequested);
+    const allCleanupRequested = $derived(
+        selectableCleanupCount > 0 && requestedCleanupCount === selectableCleanupCount,
     );
-    const someOptionalSelected = $derived(selectedOptionalCount > 0 && !allOptionalSelected);
+    const someCleanupRequested = $derived(requestedCleanupCount > 0 && !allCleanupRequested);
     const selectionLimitReached = $derived(
-        (inspection?.targetObjectIds.length ?? 0) + selectedOptionalCount >= maximumDeletionObjects &&
-            selectedOptionalCount < optionalImpacts.length,
+        (inspection?.targetObjectIds.length ?? 0) + requestedReferrerCount + requestedCleanupCount >=
+            maximumDeletionObjects,
     );
     const visibleWarnings = $derived(
         inspection?.warnings.filter((warning) => warning.code !== 'WAVE_DATA_WILL_BE_UNREFERENCED') ?? [],
@@ -72,7 +101,8 @@
     );
 
     $effect(() => {
-        if (selectAllCheckbox) selectAllCheckbox.indeterminate = someOptionalSelected;
+        if (selectAllReferrersCheckbox) selectAllReferrersCheckbox.indeterminate = someReferrersRequested;
+        if (selectAllCleanupCheckbox) selectAllCleanupCheckbox.indeterminate = someCleanupRequested;
     });
 
     function objectTypeLabel(objectType: string | null | undefined): string {
@@ -94,7 +124,7 @@
             .map((objectId) => impactsById.get(objectId))
             .filter(
                 (candidate): candidate is ObjectDeletionImpact =>
-                    candidate !== undefined && candidate.role === 'DEPENDENCY' && candidate.status === 'OPTIONAL',
+                    candidate !== undefined && candidate.role !== 'TARGET' && candidate.status === 'OPTIONAL',
             );
         return prerequisites.length === 0
             ? 0
@@ -191,14 +221,45 @@
                     </section>
                 {/if}
 
-                {#if blockedTargets.length > 0}
-                    <section class="deletion-impact-section deletion-blockers" aria-label="Cannot be deleted">
-                        <h3>Cannot be deleted</h3>
+                {#if referenceBlockedTargets.length > 0}
+                    <section class="deletion-impact-section deletion-blockers" aria-label="References must be resolved">
+                        <h3>References must be resolved</h3>
+                        <p class="deletion-section-help">
+                            Select the complete referencing chain below to make these objects eligible for deletion.
+                        </p>
+                        <div class="deletion-impact-list">
+                            {#each referenceBlockedTargets as impact (impact.objectId)}
+                                <div class="blocked deletion-impact deletion-impact-static">
+                                    <span class="deletion-impact-icon deletion-impact-icon-muted" aria-hidden="true">
+                                        <Icon name="lock" size={14} />
+                                    </span>
+                                    <span class="deletion-impact-copy">
+                                        <span class="deletion-impact-heading">
+                                            <strong>{impact.objectName}</strong>
+                                            <small>{objectTypeLabel(impact.objectType)}</small>
+                                        </span>
+                                        {#if impact.reason}<small>{impact.reason}</small>{/if}
+                                        {#each noticesFor(impact) as notice (`${notice.code}\0${notice.objectIds.join('\0')}`)}
+                                            <small>{notice.message}</small>
+                                        {/each}
+                                        {#each referencesFor(impact) as reference (`${reference.sourceObjectId}\0${reference.type}\0${reference.targetObjectId ?? ''}`)}
+                                            <small class="deletion-reference">{referenceLabel(reference)}</small>
+                                        {/each}
+                                    </span>
+                                </div>
+                            {/each}
+                        </div>
+                    </section>
+                {/if}
+
+                {#if unsafeBlockedTargets.length > 0}
+                    <section class="deletion-impact-section deletion-blockers" aria-label="Cannot be deleted safely">
+                        <h3>Cannot be deleted safely</h3>
                         <p class="deletion-section-help">
                             These selected objects will remain. Other eligible selections can still be deleted.
                         </p>
                         <div class="deletion-impact-list">
-                            {#each blockedTargets as impact (impact.objectId)}
+                            {#each unsafeBlockedTargets as impact (impact.objectId)}
                                 <div class="blocked deletion-impact deletion-impact-static">
                                     <span class="deletion-impact-icon deletion-impact-icon-muted" aria-hidden="true">
                                         <Icon name="lock" size={14} />
@@ -222,6 +283,80 @@
                     </section>
                 {/if}
 
+                {#if referrerImpacts.length > 0}
+                    <section class="deletion-impact-section deletion-optional-section" aria-label="Referencing objects">
+                        <h3>Referencing objects</h3>
+                        <p class="deletion-section-help">
+                            Delete a complete referencing chain to make the requested objects eligible.
+                        </p>
+                        <label class="deletion-select-all">
+                            <input
+                                bind:this={selectAllReferrersCheckbox}
+                                class="dialog-checkbox"
+                                type="checkbox"
+                                checked={allReferrersRequested}
+                                disabled={loading || busy}
+                                onchange={(event) => onselectall('REFERRER', event.currentTarget.checked)}
+                            />
+                            <span>
+                                {referrerImpacts.length > referrerCapacity
+                                    ? `Delete up to ${selectableReferrerCount} of ${referrerImpacts.length} referencing objects`
+                                    : `Delete all referencing objects (${referrerImpacts.length})`}
+                            </span>
+                        </label>
+                        <div class="deletion-impact-list">
+                            {#each referrerImpacts as impact (impact.objectId)}
+                                {@const disabled =
+                                    loading ||
+                                    busy ||
+                                    prerequisiteMissing(impact) ||
+                                    (selectionLimitReached && !impact.requested)}
+                                {@const missingNames = missingPrerequisiteNames(impact)}
+                                {@const depth = optionalDepth(impact)}
+                                <label
+                                    class:nested={depth > 0}
+                                    class:disabled
+                                    class="deletion-impact deletion-impact-selectable"
+                                    style={`--deletion-depth: ${depth}`}
+                                >
+                                    <input
+                                        class="dialog-checkbox"
+                                        type="checkbox"
+                                        checked={impact.requested}
+                                        {disabled}
+                                        aria-label={`Delete referencing ${objectTypeLabel(impact.objectType)} ${impact.objectName}`}
+                                        onchange={(event) =>
+                                            onselectionchange('REFERRER', impact.objectId, event.currentTarget.checked)}
+                                    />
+                                    <span class="deletion-impact-copy">
+                                        <span class="deletion-impact-heading">
+                                            <strong>{impact.objectName}</strong>
+                                            <small>{objectTypeLabel(impact.objectType)}</small>
+                                            <span class="deletion-outcome">
+                                                {impact.requested
+                                                    ? impact.selected
+                                                        ? 'Will delete'
+                                                        : 'Pending'
+                                                    : 'Keep'}
+                                            </span>
+                                        </span>
+                                        <small>
+                                            {missingNames.length > 0
+                                                ? `Available after deleting ${joinNames(missingNames)}`
+                                                : impact.reason}
+                                        </small>
+                                        <small
+                                            >{impact.volumeName || 'No volume'} · {formatStoredSize(
+                                                impact.storedSizeBytes,
+                                            )}</small
+                                        >
+                                    </span>
+                                </label>
+                            {/each}
+                        </div>
+                    </section>
+                {/if}
+
                 {#if optionalImpacts.length > 0}
                     <section class="deletion-impact-section deletion-optional-section" aria-label="Optional cleanup">
                         <h3>Optional cleanup</h3>
@@ -230,12 +365,12 @@
                         </p>
                         <label class="deletion-select-all">
                             <input
-                                bind:this={selectAllCheckbox}
-                                class="deletion-checkbox"
+                                bind:this={selectAllCleanupCheckbox}
+                                class="dialog-checkbox"
                                 type="checkbox"
-                                checked={allOptionalSelected}
+                                checked={allCleanupRequested}
                                 disabled={loading || busy}
-                                onchange={(event) => onselectall(event.currentTarget.checked)}
+                                onchange={(event) => onselectall('DEPENDENCY', event.currentTarget.checked)}
                             />
                             <span>
                                 {optionalImpacts.length > cleanupCapacity
@@ -249,7 +384,7 @@
                                     loading ||
                                     busy ||
                                     prerequisiteMissing(impact) ||
-                                    (selectionLimitReached && !impact.selected)}
+                                    (selectionLimitReached && !impact.requested)}
                                 {@const missingNames = missingPrerequisiteNames(impact)}
                                 {@const depth = optionalDepth(impact)}
                                 <label
@@ -259,21 +394,29 @@
                                     style={`--deletion-depth: ${depth}`}
                                 >
                                     <input
-                                        class="deletion-checkbox"
+                                        class="dialog-checkbox"
                                         type="checkbox"
-                                        checked={impact.selected}
+                                        checked={impact.requested}
                                         {disabled}
                                         aria-label={`Delete ${objectTypeLabel(impact.objectType)} ${impact.objectName}`}
                                         onchange={(event) =>
-                                            onselectionchange(impact.objectId, event.currentTarget.checked)}
+                                            onselectionchange(
+                                                'DEPENDENCY',
+                                                impact.objectId,
+                                                event.currentTarget.checked,
+                                            )}
                                     />
                                     <span class="deletion-impact-copy">
                                         <span class="deletion-impact-heading">
                                             <strong>{impact.objectName}</strong>
                                             <small>{objectTypeLabel(impact.objectType)}</small>
-                                            <span class="deletion-outcome"
-                                                >{impact.selected ? 'Will delete' : 'Keep'}</span
-                                            >
+                                            <span class="deletion-outcome">
+                                                {impact.requested
+                                                    ? impact.selected
+                                                        ? 'Will delete'
+                                                        : 'Pending'
+                                                    : 'Keep'}
+                                            </span>
                                         </span>
                                         <small>
                                             {missingNames.length > 0
diff --git a/apps/axkdeck/src/lib/components/ObjectDeletionDialog.test.ts b/apps/axkdeck/src/lib/components/ObjectDeletionDialog.test.ts
index f14e5035..44fc0b6a 100644
--- a/apps/axkdeck/src/lib/components/ObjectDeletionDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/ObjectDeletionDialog.test.ts
@@ -15,6 +15,8 @@ const inspection: ObjectDeletionInspection = {
     imageId: 'image-1',
     revision: 2,
     targetObjectIds: ['sample-1'],
+    referrerObjectIds: [],
+    cleanupObjectIds: [],
     selectedObjectIds: ['sample-1'],
     impacts: [
         {
@@ -26,6 +28,7 @@ const inspection: ObjectDeletionInspection = {
             volumeName: 'Piano',
             role: 'TARGET',
             status: 'REQUIRED',
+            requested: true,
             selected: true,
             storedSizeBytes: 512,
             freedClusters: 2,
@@ -41,6 +44,7 @@ const inspection: ObjectDeletionInspection = {
             volumeName: 'Piano',
             role: 'DEPENDENCY',
             status: 'OPTIONAL',
+            requested: false,
             selected: false,
             storedSizeBytes: 4096,
             freedClusters: 4,
@@ -105,9 +109,9 @@ describe('ObjectDeletionDialog', () => {
         expect(screen.getByText(/2 KiB freed/)).toBeTruthy();
 
         await fireEvent.click(screen.getByRole('checkbox', { name: 'Also delete all (1)' }));
-        expect(onselectall).toHaveBeenCalledWith(true);
+        expect(onselectall).toHaveBeenCalledWith('DEPENDENCY', true);
         await fireEvent.click(screen.getByRole('checkbox', { name: 'Delete Wave Data Piano C3 L' }));
-        expect(onselectionchange).toHaveBeenCalledWith('wave-1', true);
+        expect(onselectionchange).toHaveBeenCalledWith('DEPENDENCY', 'wave-1', true);
         await fireEvent.click(screen.getByRole('button', { name: 'Delete 1 object' }));
         expect(onconfirm).toHaveBeenCalledOnce();
     });
@@ -151,8 +155,8 @@ describe('ObjectDeletionDialog', () => {
             },
         });
 
-        expect(screen.getByRole('region', { name: 'Cannot be deleted' })).toBeTruthy();
-        expect(screen.getByRole('heading', { name: 'Cannot be deleted' })).toBeTruthy();
+        expect(screen.getByRole('region', { name: 'Cannot be deleted safely' })).toBeTruthy();
+        expect(screen.getByRole('heading', { name: 'Cannot be deleted safely' })).toBeTruthy();
         expect(screen.getByText('Program 001 still refers to this Sample.')).toBeTruthy();
         expect(screen.getByText('Referenced by Program 001: Piano')).toBeTruthy();
         expect(screen.queryByRole('heading', { name: 'References' })).toBeNull();
@@ -161,6 +165,77 @@ describe('ObjectDeletionDialog', () => {
         expect(screen.getByRole('button', { name: 'Delete 0 eligible objects' }).hasAttribute('disabled')).toBe(true);
     });
 
+    it('offers explicit upward referrer deletion before conservative descendant cleanup', async () => {
+        const onselectionchange = vi.fn();
+        const onselectall = vi.fn();
+        render(ObjectDeletionDialog, {
+            props: {
+                inspection: {
+                    ...inspection,
+                    canApply: false,
+                    selectedObjectIds: [],
+                    impacts: [
+                        {
+                            ...inspection.impacts[0]!,
+                            status: 'BLOCKED',
+                            selected: false,
+                            reason: 'References must be resolved',
+                        },
+                        {
+                            ...inspection.impacts[0]!,
+                            objectId: 'program-1',
+                            objectType: 'PROG',
+                            objectName: '001: Piano',
+                            role: 'REFERRER',
+                            status: 'OPTIONAL',
+                            requested: false,
+                            selected: false,
+                            prerequisiteObjectIds: [],
+                            reason: 'Delete this Program to resolve its Sample assignment',
+                        },
+                        inspection.impacts[1]!,
+                    ],
+                    blockers: [
+                        {
+                            code: 'incoming_reference',
+                            message: 'Program 001 still refers to this Sample.',
+                            objectIds: ['program-1', 'sample-1'],
+                        },
+                    ],
+                    references: [
+                        {
+                            sourceObjectId: 'program-1',
+                            sourceObjectType: 'PROG',
+                            sourceObjectName: '001: Piano',
+                            targetObjectId: 'sample-1',
+                            targetObjectType: 'SBNK',
+                            targetObjectName: 'Piano C3',
+                            type: 'PROG_ASSIGNMENT_TO_SBNK',
+                            quality: 'CONFIRMED',
+                            effect: 'BLOCKING',
+                        },
+                    ],
+                },
+                loading: false,
+                busy: false,
+                error: '',
+                onselectionchange,
+                onselectall,
+                oncancel: vi.fn(),
+                onconfirm: vi.fn(),
+            },
+        });
+
+        expect(screen.getByRole('heading', { name: 'References must be resolved' })).toBeTruthy();
+        expect(screen.getByRole('heading', { name: 'Referencing objects' })).toBeTruthy();
+        expect(screen.getByRole('heading', { name: 'Optional cleanup' })).toBeTruthy();
+
+        await fireEvent.click(screen.getByRole('checkbox', { name: 'Delete all referencing objects (1)' }));
+        expect(onselectall).toHaveBeenCalledWith('REFERRER', true);
+        await fireEvent.click(screen.getByRole('checkbox', { name: 'Delete referencing Program 001: Piano' }));
+        expect(onselectionchange).toHaveBeenCalledWith('REFERRER', 'program-1', true);
+    });
+
     it('allows the eligible subset of a partially blocked batch to proceed', () => {
         const blockedBank = {
             ...inspection.impacts[0]!,
@@ -199,7 +274,7 @@ describe('ObjectDeletionDialog', () => {
 
         expect(screen.getByRole('dialog', { name: 'Delete 2 objects' })).toBeTruthy();
         expect(screen.getByRole('heading', { name: 'Will be deleted' })).toBeTruthy();
-        expect(screen.getByRole('heading', { name: 'Cannot be deleted' })).toBeTruthy();
+        expect(screen.getByRole('heading', { name: 'Cannot be deleted safely' })).toBeTruthy();
         expect(screen.getByText('Program 001 still refers to this Sample Bank.')).toBeTruthy();
         expect(screen.getByText(/1 selected object remains/)).toBeTruthy();
         expect(screen.getByRole('button', { name: 'Delete 1 eligible object' }).hasAttribute('disabled')).toBe(false);
@@ -305,9 +380,10 @@ describe('ObjectDeletionDialog', () => {
             props: {
                 inspection: {
                     ...inspection,
+                    cleanupObjectIds: ['wave-1'],
                     selectedObjectIds: ['sample-1', 'wave-1'],
                     impacts: inspection.impacts.map((impact) =>
-                        impact.objectId === 'wave-1' ? { ...impact, selected: true } : impact,
+                        impact.objectId === 'wave-1' ? { ...impact, requested: true, selected: true } : impact,
                     ),
                     warnings: [],
                     estimatedFreedBytes: 496 * 1024,
@@ -335,10 +411,11 @@ describe('ObjectDeletionDialog', () => {
             props: {
                 inspection: {
                     ...inspection,
+                    cleanupObjectIds: ['wave-1'],
                     selectedObjectIds: ['sample-1', 'wave-1'],
                     impacts: [
                         inspection.impacts[0]!,
-                        { ...inspection.impacts[1]!, selected: true },
+                        { ...inspection.impacts[1]!, requested: true, selected: true },
                         {
                             ...inspection.impacts[1]!,
                             objectId: 'wave-2',
diff --git a/apps/axkdeck/src/lib/components/ObjectEditor.test.ts b/apps/axkdeck/src/lib/components/ObjectEditor.test.ts
index c2f3d8a2..8e64c74b 100644
--- a/apps/axkdeck/src/lib/components/ObjectEditor.test.ts
+++ b/apps/axkdeck/src/lib/components/ObjectEditor.test.ts
@@ -16,6 +16,7 @@ function object(objectType: string, name: string): SamplerObject {
         categoryName: objectType,
         sfsId: 0,
         storedSizeBytes: 128,
+        sizeWithDependenciesBytes: null,
         sampleRate: 44_100,
         rootKey: 60,
         frameCount: 44_100,
diff --git a/apps/axkdeck/src/lib/components/ObjectInspector.svelte b/apps/axkdeck/src/lib/components/ObjectInspector.svelte
index c2b962e7..1168d890 100644
--- a/apps/axkdeck/src/lib/components/ObjectInspector.svelte
+++ b/apps/axkdeck/src/lib/components/ObjectInspector.svelte
@@ -12,6 +12,9 @@
     }
 
     let { selection, playingObjectId = null, playheadFrame = 0 }: Props = $props();
+    function formatDependencySize(size: number | null): string {
+        return size === null ? 'Unavailable' : formatStoredSize(size);
+    }
     const heading = $derived(
         selection?.kind === 'program'
             ? 'Program details'
@@ -55,9 +58,13 @@
                     <dd>{selection.program.object.volumeName || 'Unknown'}</dd>
                 </div>
                 <div>
-                    <dt>Stored size</dt>
+                    <dt>Object size</dt>
                     <dd>{formatStoredSize(selection.program.object.storedSizeBytes)}</dd>
                 </div>
+                <div>
+                    <dt>Object size with deps.</dt>
+                    <dd>{formatDependencySize(selection.program.object.sizeWithDependenciesBytes)}</dd>
+                </div>
             </dl>
         </div>
     {:else if selection?.kind === 'sequence'}
@@ -163,9 +170,13 @@
                     <dd>{selection.item.object.volumeName || 'Unknown'}</dd>
                 </div>
                 <div>
-                    <dt>Stored size</dt>
+                    <dt>Object size</dt>
                     <dd>{formatStoredSize(selection.item.object.storedSizeBytes)}</dd>
                 </div>
+                <div>
+                    <dt>Object size with deps.</dt>
+                    <dd>{formatDependencySize(selection.item.object.sizeWithDependenciesBytes)}</dd>
+                </div>
             </dl>
         </div>
     {:else if selection?.kind === 'sample'}
@@ -194,9 +205,13 @@
                     <dd>{selection.item.object.partitionName || 'Unknown'}</dd>
                 </div>
                 <div>
-                    <dt>Stored size</dt>
+                    <dt>Object size</dt>
                     <dd>{formatStoredSize(selection.item.object.storedSizeBytes)}</dd>
                 </div>
+                <div>
+                    <dt>Object size with deps.</dt>
+                    <dd>{formatDependencySize(selection.item.object.sizeWithDependenciesBytes)}</dd>
+                </div>
             </dl>
         </div>
     {:else if selection?.kind === 'wave-data'}
diff --git a/apps/axkdeck/src/lib/components/ObjectInspector.test.ts b/apps/axkdeck/src/lib/components/ObjectInspector.test.ts
index 630baf7e..87563321 100644
--- a/apps/axkdeck/src/lib/components/ObjectInspector.test.ts
+++ b/apps/axkdeck/src/lib/components/ObjectInspector.test.ts
@@ -15,6 +15,7 @@ function object(objectType: string, name: string): SamplerObject {
         categoryName: objectType,
         sfsId: 0,
         storedSizeBytes: 128,
+        sizeWithDependenciesBytes: 1024,
         sampleRate: 0,
         rootKey: 0,
         frameCount: 0,
@@ -159,6 +160,32 @@ describe('ObjectInspector', () => {
         expect(screen.getByRole('group', { name: 'Wave Data Strings C3 Wave' })).toBeTruthy();
         expect(document.querySelectorAll('.inspector-inline-heading')).toHaveLength(2);
         expect(screen.getByText('1')).toBeTruthy();
+        expect(screen.getByText('128 B')).toBeTruthy();
+        expect(screen.getByText('1 KiB')).toBeTruthy();
+    });
+
+    it('marks an incomplete dependency closure as unavailable', () => {
+        const sampleObject = { ...object('SBNK', 'Incomplete'), sizeWithDependenciesBytes: null };
+        const item = {
+            id: sampleObject.key,
+            objectId: sampleObject.key,
+            name: sampleObject.name,
+            objectType: 'SBNK' as const,
+            object: sampleObject,
+        };
+        render(ObjectInspector, {
+            props: {
+                selection: {
+                    kind: 'sample',
+                    item,
+                    memberships: [],
+                    preview: samplePreview(item, [], 'failed'),
+                },
+            },
+        });
+
+        expect(screen.getByText('Object size with deps.')).toBeTruthy();
+        expect(screen.getByText('Unavailable')).toBeTruthy();
     });
 
     it('switches the Sample Bank waveform to the currently playing member', async () => {
diff --git a/apps/axkdeck/src/lib/components/ObjectRenameDialog.test.ts b/apps/axkdeck/src/lib/components/ObjectRenameDialog.test.ts
index 0122da77..d4393168 100644
--- a/apps/axkdeck/src/lib/components/ObjectRenameDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/ObjectRenameDialog.test.ts
@@ -21,6 +21,7 @@ const object: SamplerObject = {
     categoryName: 'PROG',
     sfsId: 8,
     storedSizeBytes: 912,
+    sizeWithDependenciesBytes: null,
     sampleRate: 0,
     rootKey: 0,
     frameCount: 0,
diff --git a/apps/axkdeck/src/lib/components/ObjectSizeIdentity.svelte b/apps/axkdeck/src/lib/components/ObjectSizeIdentity.svelte
new file mode 100644
index 00000000..84880bf4
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/ObjectSizeIdentity.svelte
@@ -0,0 +1,16 @@
+<script lang="ts">
+    import { objectSizeSummary, objectSizeTooltip } from '../objectSizePresentation';
+    import type { SamplerObject } from '../transport';
+
+    interface Props {
+        name: string;
+        object: SamplerObject;
+        metadata?: string;
+    }
+
+    let { name, object, metadata = '' }: Props = $props();
+    const tooltip = $derived(objectSizeTooltip(object));
+</script>
+
+<strong title={tooltip}>{name}</strong>
+<small title={tooltip}>{metadata ? `${metadata} · ` : ''}{objectSizeSummary(object)}</small>
diff --git a/apps/axkdeck/src/lib/components/ObjectWorkspace.svelte b/apps/axkdeck/src/lib/components/ObjectWorkspace.svelte
index 0c8feb31..c4c754eb 100644
--- a/apps/axkdeck/src/lib/components/ObjectWorkspace.svelte
+++ b/apps/axkdeck/src/lib/components/ObjectWorkspace.svelte
@@ -16,6 +16,7 @@
         type PackageExportSelectionState,
     } from '../objectSelection';
     import { compareNamedItems } from '../naturalSort';
+    import { objectSizeSummary, objectSizeTooltip } from '../objectSizePresentation';
     import type { SamplerObject } from '../transport';
     import type { ObjectRenameTarget, PackageExportObject, Program, WaveDataItem, WorkspaceView } from '../types';
     import { fixedVirtualWindow, virtualViewport, type VirtualViewportState } from '../virtualList';
@@ -384,6 +385,7 @@
                     class:selected={selection.items.some((item) => item.objectId === program.objectId)}
                     class="program-row"
                     data-navigation-index={index}
+                    title={objectSizeTooltip(program.object)}
                     aria-pressed={selection.items.some((item) => item.objectId === program.objectId)}
                     onclick={(event) => {
                         if (updateSelection(selectionMode(event), program.objectId) === 'replace')
@@ -395,6 +397,7 @@
                 >
                     <span class="object-slot">{program.slot}</span>
                     <strong>{program.name}</strong>
+                    <small class="object-size-summary">{objectSizeSummary(program.object)}</small>
                 </button>
             {:else}
                 <p class="empty-copy">No matching Programs</p>
diff --git a/apps/axkdeck/src/lib/components/ObjectWorkspace.test.ts b/apps/axkdeck/src/lib/components/ObjectWorkspace.test.ts
index ab040118..fc70fe06 100644
--- a/apps/axkdeck/src/lib/components/ObjectWorkspace.test.ts
+++ b/apps/axkdeck/src/lib/components/ObjectWorkspace.test.ts
@@ -16,6 +16,7 @@ function object(objectType: string, name: string): SamplerObject {
         categoryName: objectType,
         sfsId: 0,
         storedSizeBytes: 128,
+        sizeWithDependenciesBytes: null,
         sampleRate: 0,
         rootKey: 0,
         frameCount: 0,
@@ -90,6 +91,7 @@ describe('ObjectWorkspace', () => {
                 bitDepth: '16-bit',
                 channels: 'Mono' as const,
                 storedSizeBytes: 2,
+                sizeWithDependenciesBytes: null,
                 waveform: [],
                 previewState: 'idle' as const,
                 object: waveObject,
@@ -137,6 +139,7 @@ describe('ObjectWorkspace', () => {
                 bitDepth: '16-bit',
                 channels: 'Mono' as const,
                 storedSizeBytes: 2,
+                sizeWithDependenciesBytes: null,
                 waveform: [],
                 previewState: 'idle' as const,
                 object: waveObject,
@@ -193,6 +196,7 @@ describe('ObjectWorkspace', () => {
                 bitDepth: '16-bit',
                 channels: 'Mono' as const,
                 storedSizeBytes: 2,
+                sizeWithDependenciesBytes: null,
                 waveform: [],
                 previewState: 'idle' as const,
                 object: waveObject,
@@ -242,6 +246,7 @@ describe('ObjectWorkspace', () => {
                     bitDepth: '16-bit',
                     channels: 'Mono' as const,
                     storedSizeBytes: 2,
+                    sizeWithDependenciesBytes: null,
                     waveform: [],
                     previewState: 'idle' as const,
                     object: waveObject,
@@ -317,7 +322,7 @@ describe('ObjectWorkspace', () => {
     });
 
     it('renders Programs as factual list rows without fabricated keyboard metadata', () => {
-        const programObject = object('PROG', '001');
+        const programObject = { ...object('PROG', '001'), sizeWithDependenciesBytes: 4096 };
         render(ObjectWorkspace, {
             props: {
                 ...common,
@@ -342,6 +347,8 @@ describe('ObjectWorkspace', () => {
         expect(document.querySelector('.program-keyboard')).toBeNull();
         expect(document.querySelector('.program-list')).toBeTruthy();
         expect(document.querySelector('.program-row')).toBeTruthy();
+        expect(screen.getByText('128 B · 4 KiB incl. deps.')).toBeTruthy();
+        expect(document.querySelector('[title*="Object size with deps.: 4 KiB"]')).toBeTruthy();
         expect(document.querySelector('.object-card')).toBeNull();
         expect(screen.getByRole('searchbox', { name: 'Search Programs' })).toBeTruthy();
     });
@@ -582,6 +589,7 @@ describe('ObjectWorkspace', () => {
             bitDepth: '16-bit',
             channels: 'Mono' as const,
             storedSizeBytes: 2,
+            sizeWithDependenciesBytes: null,
             waveform: [],
             previewState: 'idle' as const,
             object: waveObject,
@@ -631,6 +639,7 @@ describe('ObjectWorkspace', () => {
             bitDepth: '16-bit',
             channels: 'Mono' as const,
             storedSizeBytes: 200,
+            sizeWithDependenciesBytes: null,
             waveform: [{ minimum: -10, maximum: 10 }],
             previewState: 'ready' as const,
             object: waveObject,
@@ -765,6 +774,7 @@ describe('ObjectWorkspace', () => {
             bitDepth: '16-bit',
             channels: 'Mono' as const,
             storedSizeBytes: 2,
+            sizeWithDependenciesBytes: null,
             waveform: [],
             previewState: 'idle' as const,
             object: waveObject,
@@ -807,6 +817,7 @@ describe('ObjectWorkspace', () => {
             bitDepth: '16-bit',
             channels: 'Mono' as const,
             storedSizeBytes: 2,
+            sizeWithDependenciesBytes: null,
             waveform: [],
             previewState: 'idle' as const,
             object: waveObject,
@@ -846,6 +857,7 @@ describe('ObjectWorkspace', () => {
             bitDepth: '16-bit',
             channels: 'Mono' as const,
             storedSizeBytes: 2,
+            sizeWithDependenciesBytes: null,
             waveform: [],
             previewState: 'idle' as const,
             object: waveObject,
@@ -889,6 +901,7 @@ describe('ObjectWorkspace', () => {
             bitDepth: '16-bit',
             channels: 'Mono' as const,
             storedSizeBytes: 2,
+            sizeWithDependenciesBytes: null,
             waveform: [],
             previewState: 'idle' as const,
             object: waveObject,
diff --git a/apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte b/apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte
index fd1fb9dd..1639f840 100644
--- a/apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte
+++ b/apps/axkdeck/src/lib/components/PackageBatchDestinationChooser.svelte
@@ -43,17 +43,12 @@
 <section class="batch-destination" aria-label="Batch destination">
     <div class="strategy-heading">
         <strong>Placement</strong>
-        <div class="strategy-control" role="group" aria-label="Package placement">
-            <button
-                type="button"
-                class:active={strategy === 'shared'}
-                aria-pressed={strategy === 'shared'}
-                {disabled}
-                onclick={() => onstrategy('shared')}>One volume</button
+        <div class="strategy-control dialog-segmented-control" role="group" aria-label="Package placement">
+            <button type="button" aria-pressed={strategy === 'shared'} {disabled} onclick={() => onstrategy('shared')}
+                >One volume</button
             >
             <button
                 type="button"
-                class:active={strategy === 'separate'}
                 aria-pressed={strategy === 'separate'}
                 disabled={disabled || !separateAvailable}
                 title={separateAvailable
@@ -98,9 +93,8 @@
 <style>
     .batch-destination {
         display: grid;
-        gap: 10px;
-        margin-bottom: 10px;
-        padding: 10px;
+        gap: 8px;
+        padding: 8px;
         border: 1px solid var(--color-border);
         border-radius: 6px;
         background: rgb(255 255 255 / 2%);
@@ -114,29 +108,7 @@
     }
 
     .strategy-control {
-        display: flex;
-    }
-
-    .strategy-control button {
-        min-height: 32px;
-        padding: 0 12px;
-        border: 1px solid var(--color-border);
-        color: var(--color-text-muted);
-        background: var(--color-bg-deep);
-    }
-
-    .strategy-control button:first-child {
-        border-radius: 5px 0 0 5px;
-    }
-
-    .strategy-control button:last-child {
-        margin-left: -1px;
-        border-radius: 0 5px 5px 0;
-    }
-
-    .strategy-control button.active {
-        color: #fff;
-        background: var(--color-accent-strong);
+        grid-template-columns: repeat(2, minmax(0, 1fr));
     }
 
     .partition-field {
diff --git a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte
index 384e1fed..1f89707b 100644
--- a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.svelte
@@ -110,54 +110,87 @@
         onconfirm,
     }: Props = $props();
     let batchPackageContent = $state<HTMLDivElement>();
+    let batchResults = $state<HTMLElement>();
 
     const busy = $derived(status === 'loading' || status === 'planning' || status === 'applying');
     const locked = $derived(status === 'applying');
     const changeSources = $derived(items.some((item) => item.localPath !== null) ? onchooselocal : onchooseworkspace);
     const selectedItems = $derived(items.filter((item) => item.selected));
     const selectedCount = $derived(selectedItems.length);
+    const displayPlan = $derived.by(() => {
+        if (!plan || plan.packages.length !== selectedItems.length) return null;
+        return plan.packages.every(
+            (summary, packageIndex) =>
+                summary.packageIndex === packageIndex &&
+                summary.packageId === selectedItems[packageIndex]?.inspection.packageId,
+        )
+            ? plan
+            : null;
+    });
     const canImport = $derived(
         status === 'ready' && Boolean(plan?.valid) && !hasUnvalidatedChanges && selectedCount > 0 && !error,
     );
-    const summaries = $derived(hasUnvalidatedChanges ? [] : (plan?.packages ?? []));
+    const summaries = $derived(displayPlan?.packages ?? []);
     const totalObjects = $derived(
-        hasUnvalidatedChanges
-            ? selectedItems.reduce((total, item) => total + item.inspection.objects.length, 0)
-            : summaries.reduce((total, item) => total + item.objectCount, 0),
+        displayPlan
+            ? summaries.reduce((total, item) => total + item.objectCount, 0)
+            : selectedItems.reduce((total, item) => total + item.inspection.objects.length, 0),
     );
     const totalPayload = $derived(
-        hasUnvalidatedChanges
-            ? selectedItems.reduce((total, item) => total + item.inspection.totalPayloadBytes, 0)
-            : summaries.reduce((total, item) => total + item.payloadBytes, 0),
+        displayPlan
+            ? summaries.reduce((total, item) => total + item.payloadBytes, 0)
+            : selectedItems.reduce((total, item) => total + item.inspection.totalPayloadBytes, 0),
     );
     const placementNodes = $derived(
         new Set(
-            plan?.programSlotPlacements.flatMap((placement) =>
+            displayPlan?.programSlotPlacements.flatMap((placement) =>
                 placement.mappings.map((mapping) => `${mapping.packageIndex}:${mapping.nodeId}`),
             ) ?? [],
         ),
     );
     const actionableRenameNodes = $derived(
         new Set(
-            plan?.actions
+            displayPlan?.actions
                 .filter((action) => action.actions.includes('CONFLICT'))
                 .map((action) => `${action.packageIndex}:${action.nodeId}`) ?? [],
         ),
     );
     const visibleConflicts = $derived(
-        hasUnvalidatedChanges
-            ? []
-            : (plan?.conflicts.filter(
-                  (conflict) =>
-                      conflict.code !== 'OPAQUE_SEQUENCE_DECISION_REQUIRED' &&
-                      conflict.code !== 'SFS_RECORD_CAPACITY_EXHAUSTED' &&
-                      !(
-                          renameConflictCodes.has(conflict.code) &&
-                          (placementNodes.has(`${conflict.packageIndex}:${conflict.nodeId}`) ||
-                              actionableRenameNodes.has(`${conflict.packageIndex}:${conflict.nodeId}`))
-                      ),
-              ) ?? []),
+        displayPlan?.conflicts.filter(
+            (conflict) =>
+                conflict.code !== 'OPAQUE_SEQUENCE_DECISION_REQUIRED' &&
+                conflict.code !== 'SFS_RECORD_CAPACITY_EXHAUSTED' &&
+                !(
+                    renameConflictCodes.has(conflict.code) &&
+                    (placementNodes.has(`${conflict.packageIndex}:${conflict.nodeId}`) ||
+                        actionableRenameNodes.has(`${conflict.packageIndex}:${conflict.nodeId}`))
+                ),
+        ) ?? [],
     );
+    const showResults = $derived(
+        Boolean(error) ||
+            (Boolean(displayPlan) &&
+                (visibleConflicts.length > 0 ||
+                    actionableRenameNodes.size > 0 ||
+                    (displayPlan?.opaqueSequences.length ?? 0) > 0 ||
+                    (displayPlan?.programSlotPlacements.length ?? 0) > 0)),
+    );
+    const footerStatus = $derived.by(() => {
+        if (status === 'loading') return 'Preparing packages…';
+        if (status === 'planning') return 'Planning batch import…';
+        if (status === 'applying') return 'Importing packages…';
+        if (error) return 'Import failed';
+        if (hasUnvalidatedChanges) {
+            if (selectedCount === 0) return 'Select at least one package';
+            return displayPlan ? 'Review import issues' : 'Check import conflicts';
+        }
+        if (visibleConflicts.length > 0) {
+            return `${visibleConflicts.length} issue${visibleConflicts.length === 1 ? '' : 's'} prevent import`;
+        }
+        if (plan && !plan.valid) return 'Review import issues';
+        if (plan?.valid) return 'Ready to import';
+        return 'Choose packages to import';
+    });
 
     function opaqueKey(itemId: string, nodeId: string): string {
         return `${itemId}:${nodeId}`;
@@ -170,7 +203,10 @@
             return;
         }
         await tick();
-        if (!error && batchPackageContent) batchPackageContent.scrollTop = 0;
+        if (error) return;
+        const tableRows = batchPackageContent?.querySelector<HTMLElement>('.batch-table-rows');
+        if (tableRows) tableRows.scrollTop = 0;
+        if (batchResults) batchResults.scrollTop = 0;
     }
 </script>
 
@@ -245,92 +281,100 @@
                     onname={ondestinationname}
                 />
 
-                {#if hasUnvalidatedChanges}
-                    <p class="batch-plan-stale" role="status">
-                        {selectedCount === 0
-                            ? 'Select at least one package.'
-                            : 'Selection or volume names changed. Check conflicts to recalculate.'}
-                    </p>
-                {/if}
-
-                <PackageBatchItemsTable
-                    {items}
-                    {plan}
-                    {destinationStrategy}
-                    {destinationVolumeName}
-                    {volumeNames}
-                    {hasUnvalidatedChanges}
-                    {busy}
-                    {onrenamevolume}
-                    {ontoggleselected}
-                    {ontoggleall}
-                />
+                <div class="batch-workspace">
+                    <div class="batch-table-region">
+                        <PackageBatchItemsTable
+                            {items}
+                            plan={displayPlan}
+                            {destinationStrategy}
+                            {destinationVolumeName}
+                            {volumeNames}
+                            {hasUnvalidatedChanges}
+                            {busy}
+                            {onrenamevolume}
+                            {ontoggleselected}
+                            {ontoggleall}
+                        />
+                    </div>
 
-                {#if !hasUnvalidatedChanges && plan?.opaqueSequences.length}
-                    <section class="batch-sequence-decisions" aria-label="Sequence decisions">
-                        {#each plan.opaqueSequences as sequence (`${sequence.packageIndex}:${sequence.nodeId}`)}
-                            {@const packageIndex = sequence.packageIndex ?? 0}
-                            {@const item = selectedItems[packageIndex]}
-                            {@const selected = item
-                                ? (opaqueSequenceActions[opaqueKey(item.id, sequence.nodeId)] ?? sequence.action)
-                                : sequence.action}
-                            {#if item}<fieldset>
-                                    <legend>Sequence “{sequence.name || 'Unnamed'}” could not be decoded</legend>
-                                    <small>Choose whether to preserve its original bytes or leave it out.</small>
-                                    <label>
-                                        <input
-                                            type="radio"
-                                            name={`batch-sequence-${packageIndex}-${sequence.nodeId}`}
-                                            checked={selected === 'PRESERVE_UNCHANGED'}
-                                            disabled={busy}
-                                            onchange={() =>
-                                                onopaquesequenceaction(item.id, sequence.nodeId, 'PRESERVE_UNCHANGED')}
-                                        />
-                                        Preserve unchanged
-                                    </label>
-                                    <label>
-                                        <input
-                                            type="radio"
-                                            name={`batch-sequence-${packageIndex}-${sequence.nodeId}`}
-                                            checked={selected === 'SKIP'}
-                                            disabled={busy}
-                                            onchange={() => onopaquesequenceaction(item.id, sequence.nodeId, 'SKIP')}
-                                        />
-                                        Skip Sequence
-                                    </label>
-                                </fieldset>{/if}
-                        {/each}
-                    </section>
-                {/if}
+                    {#if showResults}
+                        <section class="batch-results" aria-label="Import results" bind:this={batchResults}>
+                            {#if displayPlan?.opaqueSequences.length}
+                                <section class="batch-sequence-decisions" aria-label="Sequence decisions">
+                                    {#each displayPlan.opaqueSequences as sequence (`${sequence.packageIndex}:${sequence.nodeId}`)}
+                                        {@const packageIndex = sequence.packageIndex ?? 0}
+                                        {@const item = selectedItems[packageIndex]}
+                                        {@const selected = item
+                                            ? (opaqueSequenceActions[opaqueKey(item.id, sequence.nodeId)] ??
+                                              sequence.action)
+                                            : sequence.action}
+                                        {#if item}<fieldset>
+                                                <legend
+                                                    >Sequence “{sequence.name || 'Unnamed'}” could not be decoded</legend
+                                                >
+                                                <small
+                                                    >Choose whether to preserve its original bytes or leave it out.</small
+                                                >
+                                                <label>
+                                                    <input
+                                                        type="radio"
+                                                        name={`batch-sequence-${packageIndex}-${sequence.nodeId}`}
+                                                        checked={selected === 'PRESERVE_UNCHANGED'}
+                                                        disabled={busy}
+                                                        onchange={() =>
+                                                            onopaquesequenceaction(
+                                                                item.id,
+                                                                sequence.nodeId,
+                                                                'PRESERVE_UNCHANGED',
+                                                            )}
+                                                    />
+                                                    Preserve unchanged
+                                                </label>
+                                                <label>
+                                                    <input
+                                                        type="radio"
+                                                        name={`batch-sequence-${packageIndex}-${sequence.nodeId}`}
+                                                        checked={selected === 'SKIP'}
+                                                        disabled={busy}
+                                                        onchange={() =>
+                                                            onopaquesequenceaction(item.id, sequence.nodeId, 'SKIP')}
+                                                    />
+                                                    Skip Sequence
+                                                </label>
+                                            </fieldset>{/if}
+                                    {/each}
+                                </section>
+                            {/if}
 
-                {#if !hasUnvalidatedChanges && plan}
-                    <PackageBatchConflictControls
-                        items={selectedItems}
-                        {plan}
-                        {renames}
-                        {programSlots}
-                        disabled={busy}
-                        {onrename}
-                        {onprogramslot}
-                        {onprogramstart}
-                    />
-                {/if}
+                            {#if displayPlan}
+                                <PackageBatchConflictControls
+                                    items={selectedItems}
+                                    plan={displayPlan}
+                                    {renames}
+                                    {programSlots}
+                                    disabled={busy}
+                                    {onrename}
+                                    {onprogramslot}
+                                    {onprogramstart}
+                                />
+                            {/if}
 
-                {#if visibleConflicts.length > 0}
-                    <section class="batch-conflicts" role="alert">
-                        <strong
-                            >{visibleConflicts.length} issue{visibleConflicts.length === 1 ? '' : 's'} prevent import</strong
-                        >
-                        {#each visibleConflicts as conflict (`${conflict.packageIndex}:${conflict.code}:${conflict.nodeId}`)}
-                            <p>{conflict.message}</p>
-                        {/each}
-                    </section>
-                {:else if plan?.valid && !hasUnvalidatedChanges && !error}
-                    <p class="batch-ready"><Icon name="check" size={14} /> Ready to import</p>
-                {/if}
+                            {#if visibleConflicts.length > 0}
+                                <section class="batch-conflicts" role="alert">
+                                    <strong
+                                        >{visibleConflicts.length} issue{visibleConflicts.length === 1 ? '' : 's'} prevent
+                                        import</strong
+                                    >
+                                    {#each visibleConflicts as conflict (`${conflict.packageIndex}:${conflict.code}:${conflict.nodeId}`)}
+                                        <p>{conflict.message}</p>
+                                    {/each}
+                                </section>
+                            {/if}
+                            {#if error}<p class="dialog-error" role="alert">{error}</p>{/if}
+                        </section>
+                    {/if}
+                </div>
             {/if}
-            {#if status === 'planning'}<p class="dialog-progress" role="status">Planning batch import…</p>{/if}
-            {#if error}<p class="dialog-error" role="alert">{error}</p>{/if}
         </div>
 
         <footer class="dialog-footer batch-package-footer">
@@ -341,9 +385,12 @@
                     disabled={busy || selectedCount === 0}
                     onclick={() => void replanAndRevealSummary()}
                 >
-                    {status === 'planning' ? 'Checking conflicts…' : 'Check conflicts'}
+                    Check conflicts
                 </button>
             {/if}
+            <p class:error-status={Boolean(error)} class="batch-footer-status" role="status" aria-live="polite">
+                {footerStatus}
+            </p>
             <div class="batch-package-footer-actions">
                 <button class="secondary-button" type="button" disabled={locked} onclick={oncancel}>Cancel</button>
                 {#if items.length > 0}
@@ -365,9 +412,13 @@
     }
 
     .batch-package-content {
+        display: flex;
+        flex: 1;
+        flex-direction: column;
         min-height: 0;
-        overflow: auto;
-        padding: 12px 14px;
+        gap: 8px;
+        overflow: hidden;
+        padding: 10px 12px;
     }
 
     .batch-progress,
@@ -389,7 +440,6 @@
 
     .batch-summary {
         justify-content: space-between;
-        margin-bottom: 10px;
     }
 
     .batch-summary div {
@@ -399,19 +449,37 @@
 
     .batch-summary small,
     .batch-sequence-decisions small {
-        color: var(--text-muted);
+        color: var(--color-text-muted);
+        font-size: var(--dialog-metadata-font-size);
     }
 
-    .batch-plan-stale {
-        margin: 0 0 10px;
-        color: var(--text-muted);
+    .batch-workspace,
+    .batch-table-region {
+        display: grid;
+        min-height: 0;
+    }
+
+    .batch-workspace {
+        flex: 1;
+        grid-template-rows: minmax(140px, 1fr) auto;
+        gap: 8px;
+    }
+
+    .batch-table-region {
+        overflow: hidden;
+    }
+
+    .batch-results {
+        max-height: min(220px, 30vh);
+        overflow-y: auto;
+        border-top: 1px solid var(--color-border);
+        padding-top: 8px;
     }
 
     .batch-sequence-decisions,
     .batch-conflicts {
         display: grid;
         gap: 10px;
-        margin-top: 10px;
         padding: 10px;
         border: 1px solid #765d2d;
         border-radius: 6px;
@@ -435,16 +503,19 @@
         margin: 0;
     }
 
-    .batch-ready {
-        display: flex;
-        align-items: center;
-        gap: 6px;
-        margin: 10px 0 0;
-        color: #85d8ad;
-    }
-
     .batch-package-footer {
         flex-wrap: wrap;
+        justify-content: flex-start;
+    }
+
+    .batch-footer-status {
+        margin: 0;
+        color: var(--color-text-muted);
+        font-size: var(--dialog-metadata-font-size);
+    }
+
+    .batch-footer-status.error-status {
+        color: var(--color-danger);
     }
 
     .batch-package-footer-actions {
diff --git a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts
index d21c38a5..6be87673 100644
--- a/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/PackageBatchImportDialog.test.ts
@@ -9,6 +9,17 @@ import PackageBatchImportDialog from './PackageBatchImportDialog.svelte';
 
 const dialogSource = readFileSync(resolve(process.cwd(), 'src/lib/components/PackageBatchImportDialog.svelte'), 'utf8');
 const tableSource = readFileSync(resolve(process.cwd(), 'src/lib/components/PackageBatchItemsTable.svelte'), 'utf8');
+const destinationSource = readFileSync(
+    resolve(process.cwd(), 'src/lib/components/PackageBatchDestinationChooser.svelte'),
+    'utf8',
+);
+const appStyles = readFileSync(resolve(process.cwd(), 'src/app.css'), 'utf8');
+
+function styleRule(styles: string, selector: string): string {
+    const start = styles.indexOf(`${selector} {`);
+    const end = styles.indexOf('}', start);
+    return start < 0 || end < 0 ? '' : styles.slice(start, end + 1);
+}
 
 function inspection(packageId: string, volumeName: string): PackageInspection {
     return {
@@ -166,6 +177,44 @@ function props() {
     };
 }
 
+function planWithRenameConflicts(): ImageSessionPackageImportPlan {
+    const conflicted = structuredClone(plan);
+    conflicted.valid = false;
+    conflicted.conflicts = items.map((item, packageIndex) => ({
+        code: 'SFS_NAME_CONFLICT',
+        message: `Directory already contains entry Sample ${packageIndex + 1}`,
+        packageIndex,
+        rootIndex: 0,
+        packageId: item.inspection.packageId,
+        nodeId: `sample-${packageIndex + 1}`,
+        partitionIndex: 0,
+        groupName: '',
+        volumeName: conflicted.packages[packageIndex].destinationVolumeName,
+        rawGroup: '',
+        rawVolume: '',
+    }));
+    conflicted.actions = items.map((item, packageIndex) => ({
+        actionId: `rename-${packageIndex + 1}`,
+        actions: ['CONFLICT'],
+        canonicalActionId: null,
+        destinationName: `Sample ${packageIndex + 1}`,
+        groupName: '',
+        nodeId: `sample-${packageIndex + 1}`,
+        objectType: 'SBNK',
+        packageId: item.inspection.packageId,
+        packageIndex,
+        partitionIndex: 0,
+        rawGroup: '',
+        rawVolume: '',
+        rootIndex: 0,
+        sourceName: `Sample ${packageIndex + 1}`,
+        targetSfsId: null,
+        targetWaveDataReferenceValue: null,
+        volumeName: conflicted.packages[packageIndex].destinationVolumeName,
+    }));
+    return conflicted;
+}
+
 describe('PackageBatchImportDialog', () => {
     beforeEach(() => vi.clearAllMocks());
 
@@ -209,11 +258,12 @@ describe('PackageBatchImportDialog', () => {
         expect(screen.getByText(/2 packages will be imported into one volume/)).toBeTruthy();
         expect(screen.getByRole('button', { name: 'One volume' }).getAttribute('aria-pressed')).toBe('true');
         expect(screen.getByRole('button', { name: 'Separate volumes' }).hasAttribute('disabled')).toBe(true);
-        expect((screen.getByRole('combobox', { name: 'Volume' }) as HTMLInputElement).value).toBe(
-            'Partition 1 / Existing',
+        expect((screen.getByRole('combobox', { name: 'Destination partition' }) as HTMLSelectElement).value).toBe('0');
+        expect((screen.getByRole('combobox', { name: 'Destination volume' }) as HTMLInputElement).value).toBe(
+            'Existing',
         );
 
-        await fireEvent.click(screen.getByRole('button', { name: 'New volume' }));
+        await fireEvent.click(screen.getByRole('button', { name: 'New' }));
         expect(callbacks.ondestinationmode).toHaveBeenCalledWith('create');
     });
 
@@ -244,7 +294,7 @@ describe('PackageBatchImportDialog', () => {
         expect(screen.getByText('1 of 2 packages selected')).toBeTruthy();
         expect(screen.getByText('Not included')).toBeTruthy();
         expect(screen.queryByText('SFS record capacity')).toBeNull();
-        expect(screen.getByText('Selection or volume names changed. Check conflicts to recalculate.')).toBeTruthy();
+        expect(screen.getByRole('status').textContent).toContain('Check import conflicts');
 
         await fireEvent.click(screen.getByRole('checkbox', { name: 'Include two.axkvol' }));
         expect(callbacks.ontoggleselected).toHaveBeenCalledWith('item-1', true);
@@ -261,7 +311,7 @@ describe('PackageBatchImportDialog', () => {
             },
         });
 
-        expect(screen.getByText('Select at least one package.')).toBeTruthy();
+        expect(screen.getByRole('status').textContent).toContain('Select at least one package');
         expect(screen.getByRole('button', { name: 'Check conflicts' }).hasAttribute('disabled')).toBe(true);
         expect(screen.getByRole('button', { name: 'Import 0 packages' }).hasAttribute('disabled')).toBe(true);
     });
@@ -279,7 +329,62 @@ describe('PackageBatchImportDialog', () => {
         expect(screen.getByRole('button', { name: 'Import 2 packages' }).hasAttribute('disabled')).toBe(true);
     });
 
-    it('keeps conflict checking in the fixed footer and uses compact top-aligned rows', () => {
+    it('prompts for the first explicit conflict check before any plan exists', () => {
+        render(PackageBatchImportDialog, {
+            props: {
+                ...props(),
+                plan: null,
+                hasUnvalidatedChanges: true,
+            },
+        });
+
+        expect(screen.getByRole('status').textContent).toContain('Check import conflicts');
+        expect(callbacks.onreplan).not.toHaveBeenCalled();
+        expect(screen.getByRole('button', { name: 'Import 2 packages' }).hasAttribute('disabled')).toBe(true);
+    });
+
+    it('keeps every rename conflict editable while draft names await one explicit check', async () => {
+        render(PackageBatchImportDialog, {
+            props: {
+                ...props(),
+                plan: planWithRenameConflicts(),
+                renames: { 'item-0:sample-1': 'Kick fixed' },
+                hasUnvalidatedChanges: true,
+            },
+        });
+
+        expect(screen.getByText('Choose unused destination names')).toBeTruthy();
+        expect((screen.getByLabelText('one.axkvol · Sample 1') as HTMLInputElement).value).toBe('Kick fixed');
+        const secondRename = screen.getByLabelText('two.axkvol · Sample 2') as HTMLInputElement;
+        expect(secondRename.value).toBe('Sample 2');
+        expect(screen.getByText('SFS record capacity')).toBeTruthy();
+        expect(screen.getByRole('status').textContent).toContain('Review import issues');
+        expect(screen.getByRole('button', { name: 'Import 2 packages' }).hasAttribute('disabled')).toBe(true);
+
+        await fireEvent.input(secondRename, { target: { value: 'Snare fixed' } });
+        expect(callbacks.onrename).toHaveBeenCalledWith('item-1', 'sample-2', 'Snare fixed');
+        expect(callbacks.onreplan).not.toHaveBeenCalled();
+
+        await fireEvent.click(screen.getByRole('button', { name: 'Check conflicts' }));
+        expect(callbacks.onreplan).toHaveBeenCalledOnce();
+    });
+
+    it('hides indexed plan controls when the selected package set no longer matches the plan', () => {
+        render(PackageBatchImportDialog, {
+            props: {
+                ...props(),
+                items: items.map((item, index) => ({ ...item, selected: index === 0 })),
+                plan: planWithRenameConflicts(),
+                hasUnvalidatedChanges: true,
+            },
+        });
+
+        expect(screen.queryByText('Choose unused destination names')).toBeNull();
+        expect(screen.queryByText('SFS record capacity')).toBeNull();
+        expect(screen.getByText('Pending check')).toBeTruthy();
+    });
+
+    it('keeps conflict checking and readiness in the fixed footer', () => {
         render(PackageBatchImportDialog, { props: props() });
 
         const checkConflicts = screen.getByRole('button', { name: 'Check conflicts' });
@@ -289,10 +394,8 @@ describe('PackageBatchImportDialog', () => {
             Array.from(footer?.querySelectorAll('button') ?? []).map((button) => button.textContent?.trim()),
         ).toEqual(['Check conflicts', 'Cancel', 'Import 2 packages']);
         expect(footer?.querySelector('.batch-package-footer-actions')).toBeTruthy();
-        expect(screen.getByText('21').tagName).toBe('SPAN');
-        expect(tableSource).toMatch(/\.batch-table-row\s*\{[^}]*align-items:\s*start;/s);
-        expect(tableSource).toMatch(/\.batch-table-row\s*\{[^}]*padding-block:\s*6px;/s);
-        expect(dialogSource).toMatch(/\.batch-package-footer\s*\{[^}]*flex-wrap:\s*wrap;/s);
+        expect(footer?.querySelector('[role="status"]')?.textContent).toContain('Ready to import');
+        expect(screen.queryByText('Ready to import', { selector: '.batch-package-content *' })).toBeNull();
     });
 
     it('disables conflict checking and reports progress while planning', () => {
@@ -300,12 +403,12 @@ describe('PackageBatchImportDialog', () => {
             props: { ...props(), status: 'planning' },
         });
 
-        const checking = screen.getByRole('button', { name: 'Checking conflicts…' });
+        const checking = screen.getByRole('button', { name: 'Check conflicts' });
         expect(checking.hasAttribute('disabled')).toBe(true);
         expect(screen.getByRole('status').textContent).toContain('Planning batch import…');
     });
 
-    it('scrolls to the capacity summary after a successful conflict check', async () => {
+    it('resets the package and result scrollers after a successful conflict check', async () => {
         let completeCheck: (() => void) | undefined;
         callbacks.onreplan.mockReturnValueOnce(
             new Promise<void>((resolveCheck) => {
@@ -315,15 +418,15 @@ describe('PackageBatchImportDialog', () => {
         render(PackageBatchImportDialog, {
             props: { ...props(), hasUnvalidatedChanges: true },
         });
-        const content = screen.getByRole('dialog').querySelector<HTMLElement>('.batch-package-content');
-        expect(content).toBeTruthy();
-        content!.scrollTop = 480;
+        const rows = screen.getByRole('dialog').querySelector<HTMLElement>('.batch-table-rows');
+        expect(rows).toBeTruthy();
+        rows!.scrollTop = 480;
 
         await fireEvent.click(screen.getByRole('button', { name: 'Check conflicts' }));
-        expect(content!.scrollTop).toBe(480);
+        expect(rows!.scrollTop).toBe(480);
         completeCheck?.();
 
-        await waitFor(() => expect(content!.scrollTop).toBe(0));
+        await waitFor(() => expect(rows!.scrollTop).toBe(0));
     });
 
     it('keeps the current scroll position when conflict checking reports an error', async () => {
@@ -332,14 +435,55 @@ describe('PackageBatchImportDialog', () => {
         callbacks.onreplan.mockImplementationOnce(async () => {
             await rendered.rerender({ ...initialProps, error: 'Conflict planning failed' });
         });
-        const content = screen.getByRole('dialog').querySelector<HTMLElement>('.batch-package-content');
-        expect(content).toBeTruthy();
-        content!.scrollTop = 480;
+        const rows = screen.getByRole('dialog').querySelector<HTMLElement>('.batch-table-rows');
+        expect(rows).toBeTruthy();
+        rows!.scrollTop = 480;
 
         await fireEvent.click(screen.getByRole('button', { name: 'Check conflicts' }));
 
         await waitFor(() => expect(screen.getByRole('alert').textContent).toContain('Conflict planning failed'));
-        expect(content!.scrollTop).toBe(480);
+        expect(rows!.scrollTop).toBe(480);
+    });
+
+    it('uses compact shared dialog controls and a fixed-header scrolling package table', () => {
+        render(PackageBatchImportDialog, { props: props() });
+
+        const selectAll = screen.getByRole('checkbox', { name: 'Select all packages' });
+        const packageCheckbox = screen.getByRole('checkbox', { name: 'Include one.axkvol' });
+        expect(selectAll.classList).toContain('dialog-checkbox');
+        expect(packageCheckbox.classList).toContain('dialog-checkbox');
+        expect(screen.getByRole('group', { name: 'Package placement' }).classList).toContain(
+            'dialog-segmented-control',
+        );
+        expect(screen.getByRole('rowgroup')).toBeTruthy();
+        expect(screen.getByRole('columnheader', { name: 'Package' }).closest('.batch-table-header')).toBeTruthy();
+
+        expect(appStyles).toContain('--dialog-body-font-size: 11px');
+        expect(appStyles).toContain('--dialog-table-header-font-size: 10px');
+        expect(appStyles).toMatch(/\.dialog-shell\s*\{[^}]*font-size:\s*var\(--dialog-body-font-size\)/s);
+        expect(appStyles).toMatch(/\.dialog-checkbox\s*\{[^}]*appearance:\s*none/s);
+        expect(appStyles).toMatch(/\.dialog-checkbox:indeterminate::before\s*\{/);
+        expect(destinationSource).toContain('dialog-segmented-control');
+        expect(styleRule(tableSource, '.batch-table-rows')).toContain('overflow-y: auto');
+        expect(tableSource).toMatch(
+            /\.batch-table-header\s*\{[^}]*font-size:\s*var\(--dialog-table-header-font-size\)/s,
+        );
+        expect(tableSource).toMatch(/\.batch-table-row\s*\{[^}]*align-items:\s*start/s);
+        expect(tableSource).toMatch(/\.batch-table-row\s*\{[^}]*padding-block:\s*5px/s);
+        expect(dialogSource).toMatch(/\.batch-package-content\s*\{[^}]*overflow:\s*hidden/s);
+    });
+
+    it('keeps detailed planning errors in a separately scrolling results panel', () => {
+        render(PackageBatchImportDialog, {
+            props: { ...props(), error: 'Alteration journal storage is full' },
+        });
+
+        const alert = screen.getByRole('alert');
+        const results = alert.closest('.batch-results');
+        expect(results).toBeTruthy();
+        expect(results?.getAttribute('aria-label')).toBe('Import results');
+        expect(screen.getByRole('status').textContent).toContain('Import failed');
+        expect(styleRule(dialogSource, '.batch-results')).toContain('overflow-y: auto');
     });
 
     it('does not report readiness while an apply error is visible', () => {
diff --git a/apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte b/apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte
index d32cfe11..958d35af 100644
--- a/apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte
+++ b/apps/axkdeck/src/lib/components/PackageBatchItemsTable.svelte
@@ -34,10 +34,8 @@
     const allSelected = $derived(items.length > 0 && selectedItems.length === items.length);
     const someSelected = $derived(selectedItems.length > 0 && !allSelected);
     const packageIndexById = $derived(new Map(selectedItems.map((item, index) => [item.id, index])));
-    const summaries = $derived(hasUnvalidatedChanges ? [] : (plan?.packages ?? []));
-    const capacityReports = $derived(
-        hasUnvalidatedChanges ? [] : (plan?.sfsIndexCapacity.filter((capacity) => capacity.packages.length > 0) ?? []),
-    );
+    const summaries = $derived(plan?.packages ?? []);
+    const capacityReports = $derived(plan?.sfsIndexCapacity.filter((capacity) => capacity.packages.length > 0) ?? []);
     const capacityByPackage = $derived.by(() => {
         const result = new Map<number, (typeof capacityReports)[number]['packages'][number]>();
         for (const capacity of capacityReports) {
@@ -58,156 +56,176 @@
     });
 </script>
 
-{#each capacityReports as capacity (capacity.partitionIndex)}
-    <section
-        class:capacity-unavailable={capacity.shortfallRecordSlots > 0}
-        class="capacity-summary"
-        aria-label={`SFS record capacity for partition ${capacity.partitionIndex + 1}`}
-    >
-        <div class="capacity-heading">
-            <strong>SFS record capacity</strong>
-            <small>
-                Partition {capacity.partitionIndex + 1} · {capacity.indexBlockCount} blocks ×
-                {capacity.recordsPerIndexBlock} records · {capacity.reservedRecordSlots} reserved
-            </small>
-        </div>
-        <div class="capacity-metrics">
-            <span>{capacity.freeRecordSlots} free</span>
-            <span>{capacity.requiredRecordSlots} required</span>
-            {#if capacity.shortfallRecordSlots > 0}
-                <strong>{capacity.shortfallRecordSlots} short</strong>
-            {:else}
-                <span>{capacity.remainingRecordSlots} remaining</span>
-            {/if}
-        </div>
-    </section>
-{/each}
-
-<div class="batch-table" role="table" aria-label="Packages to import">
-    <div class="batch-table-header" role="row">
-        <span class="selection-cell" role="columnheader">
-            <input
-                bind:this={selectAllCheckbox}
-                type="checkbox"
-                checked={allSelected}
-                disabled={busy}
-                aria-label="Select all packages"
-                onchange={(event) => ontoggleall(event.currentTarget.checked)}
-            />
-        </span>
-        <span role="columnheader">Package</span>
-        <span role="columnheader">Destination</span>
-        <span role="columnheader">Contents</span>
-        <span role="columnheader">SFS records</span>
+<div class="batch-items">
+    <div class="capacity-summaries">
+        {#each capacityReports as capacity (capacity.partitionIndex)}
+            <section
+                class:capacity-unavailable={capacity.shortfallRecordSlots > 0}
+                class="capacity-summary"
+                aria-label={`SFS record capacity for partition ${capacity.partitionIndex + 1}`}
+            >
+                <div class="capacity-heading">
+                    <strong>SFS record capacity</strong>
+                    <small>
+                        Partition {capacity.partitionIndex + 1} · {capacity.indexBlockCount} blocks ×
+                        {capacity.recordsPerIndexBlock} records · {capacity.reservedRecordSlots} reserved
+                    </small>
+                </div>
+                <div class="capacity-metrics">
+                    <span>{capacity.freeRecordSlots} free</span>
+                    <span>{capacity.requiredRecordSlots} required</span>
+                    {#if capacity.shortfallRecordSlots > 0}
+                        <strong>{capacity.shortfallRecordSlots} short</strong>
+                    {:else}
+                        <span>{capacity.remainingRecordSlots} remaining</span>
+                    {/if}
+                </div>
+            </section>
+        {/each}
     </div>
-    {#each items as item (item.id)}
-        {@const packageIndex = packageIndexById.get(item.id)}
-        {@const summary = summaries.find((entry) => entry.packageIndex === packageIndex)}
-        {@const recordUsage = packageIndex === undefined ? undefined : capacityByPackage.get(packageIndex)}
-        {@const allocatableRecords =
-            packageIndex === undefined ? 0 : (allocatableRecordsByPackage.get(packageIndex) ?? 0)}
-        {@const cannotFitEmptyPartition =
-            recordUsage !== undefined && recordUsage.standaloneRequiredRecordSlots > allocatableRecords}
-        <div class:row-excluded={!item.selected} class="batch-table-row" role="row">
-            <div class="selection-cell" role="cell">
+
+    <div class="batch-table" role="table" aria-label="Packages to import">
+        <div class="batch-table-header" role="row">
+            <span class="selection-cell" role="columnheader">
                 <input
+                    bind:this={selectAllCheckbox}
+                    class="dialog-checkbox"
                     type="checkbox"
-                    checked={item.selected}
+                    checked={allSelected}
                     disabled={busy}
-                    aria-label={`Include ${item.sourceName}`}
-                    onchange={(event) => ontoggleselected(item.id, event.currentTarget.checked)}
+                    aria-label="Select all packages"
+                    onchange={(event) => ontoggleall(event.currentTarget.checked)}
                 />
-            </div>
-            <div role="cell">
-                <strong>{item.sourceName}</strong>
-                <small>{formatStoredSize(item.inspection.totalPayloadBytes)}</small>
-            </div>
-            <div role="cell">
-                {#if destinationStrategy === 'separate'}
-                    <label>
-                        <span class="sr-only">New volume name for {item.sourceName}</span>
+            </span>
+            <span role="columnheader">Package</span>
+            <span role="columnheader">Destination</span>
+            <span role="columnheader">Contents</span>
+            <span role="columnheader">SFS records</span>
+        </div>
+        <div class="batch-table-rows" role="rowgroup">
+            {#each items as item (item.id)}
+                {@const packageIndex = packageIndexById.get(item.id)}
+                {@const summary = summaries.find((entry) => entry.packageIndex === packageIndex)}
+                {@const recordUsage = packageIndex === undefined ? undefined : capacityByPackage.get(packageIndex)}
+                {@const allocatableRecords =
+                    packageIndex === undefined ? 0 : (allocatableRecordsByPackage.get(packageIndex) ?? 0)}
+                {@const cannotFitEmptyPartition =
+                    recordUsage !== undefined && recordUsage.standaloneRequiredRecordSlots > allocatableRecords}
+                <div class:row-excluded={!item.selected} class="batch-table-row" role="row">
+                    <div class="selection-cell" role="cell">
                         <input
-                            class="dialog-field-control"
-                            type="text"
-                            value={volumeNames[item.id] ??
-                                summary?.destinationVolumeName ??
-                                item.inspection.roots[0]?.displayName ??
-                                ''}
-                            maxlength="16"
-                            disabled={busy || !item.selected}
-                            oninput={(event) => onrenamevolume(item.id, event.currentTarget.value)}
+                            class="dialog-checkbox"
+                            type="checkbox"
+                            checked={item.selected}
+                            disabled={busy}
+                            aria-label={`Include ${item.sourceName}`}
+                            onchange={(event) => ontoggleselected(item.id, event.currentTarget.checked)}
                         />
-                    </label>
-                {:else if item.selected}
-                    <span>{destinationVolumeName || 'Choose a volume'}</span>
-                {:else}
-                    <span>Not included</span>
-                {/if}
-            </div>
-            <div class="object-counts" role="cell">
-                {#if summary}
-                    <span>{summary.objectCounts.programs} Programs</span>
-                    <span>{summary.objectCounts.sampleBanks} Sample Banks</span>
-                    <span>{summary.objectCounts.samples} Samples</span>
-                    <span>{summary.objectCounts.waveData} Wave Data</span>
-                    <span>{summary.objectCounts.sequences} Sequences</span>
-                {:else}
-                    <span>{item.inspection.objects.length} objects</span>
-                {/if}
-            </div>
-            <div
-                class:record-unavailable={Boolean(recordUsage?.shortfallRecordSlots)}
-                class:record-impossible={cannotFitEmptyPartition}
-                class="record-usage"
-                role="cell"
-                title={cannotFitEmptyPartition
-                    ? `Requires ${recordUsage?.standaloneRequiredRecordSlots} records on an empty partition; maximum ${allocatableRecords}`
-                    : undefined}
-            >
-                {#if !item.selected}
-                    <span>Not included</span>
-                {:else if hasUnvalidatedChanges}
-                    <span>Pending check</span>
-                {:else if recordUsage}
-                    <span>{recordUsage.plannedRecordSlots}</span>
-                    <small>
-                        {recordUsage.plannedObjectRecordSlots} objects
-                        {#if recordUsage.volumeScaffoldingRecordSlots > 0}
-                            + {recordUsage.volumeScaffoldingRecordSlots} volume
+                    </div>
+                    <div class="package-cell" role="cell">
+                        <strong>{item.sourceName}</strong>
+                        <small>{formatStoredSize(item.inspection.totalPayloadBytes)}</small>
+                    </div>
+                    <div role="cell">
+                        {#if destinationStrategy === 'separate'}
+                            <label>
+                                <span class="sr-only">New volume name for {item.sourceName}</span>
+                                <input
+                                    class="dialog-field-control"
+                                    type="text"
+                                    value={volumeNames[item.id] ??
+                                        summary?.destinationVolumeName ??
+                                        item.inspection.roots[0]?.displayName ??
+                                        ''}
+                                    maxlength="16"
+                                    disabled={busy || !item.selected}
+                                    oninput={(event) => onrenamevolume(item.id, event.currentTarget.value)}
+                                />
+                            </label>
+                        {:else if item.selected}
+                            <span>{destinationVolumeName || 'Choose a volume'}</span>
+                        {:else}
+                            <span>Not included</span>
                         {/if}
-                        {#if recordUsage.reusedObjectCount > 0}· {recordUsage.reusedObjectCount} reused{/if}
-                        {#if recordUsage.shortfallRecordSlots > 0}· {recordUsage.shortfallRecordSlots} short{/if}
-                    </small>
-                {:else}
-                    <span>—</span>
-                {/if}
-            </div>
+                    </div>
+                    <div class="object-counts" role="cell">
+                        {#if summary}
+                            <span>{summary.objectCounts.programs} Programs</span>
+                            <span>{summary.objectCounts.sampleBanks} Sample Banks</span>
+                            <span>{summary.objectCounts.samples} Samples</span>
+                            <span>{summary.objectCounts.waveData} Wave Data</span>
+                            <span>{summary.objectCounts.sequences} Sequences</span>
+                        {:else}
+                            <span>{item.inspection.objects.length} objects</span>
+                        {/if}
+                    </div>
+                    <div
+                        class:record-unavailable={Boolean(recordUsage?.shortfallRecordSlots)}
+                        class:record-impossible={cannotFitEmptyPartition}
+                        class="record-usage"
+                        role="cell"
+                        title={cannotFitEmptyPartition
+                            ? `Requires ${recordUsage?.standaloneRequiredRecordSlots} records on an empty partition; maximum ${allocatableRecords}`
+                            : undefined}
+                    >
+                        {#if !item.selected}
+                            <span>Not included</span>
+                        {:else if recordUsage}
+                            <span>{recordUsage.plannedRecordSlots}</span>
+                            <small>
+                                {recordUsage.plannedObjectRecordSlots} objects
+                                {#if recordUsage.volumeScaffoldingRecordSlots > 0}
+                                    + {recordUsage.volumeScaffoldingRecordSlots} volume
+                                {/if}
+                                {#if recordUsage.reusedObjectCount > 0}· {recordUsage.reusedObjectCount} reused{/if}
+                                {#if recordUsage.shortfallRecordSlots > 0}· {recordUsage.shortfallRecordSlots} short{/if}
+                            </small>
+                        {:else if hasUnvalidatedChanges}
+                            <span>Pending check</span>
+                        {:else}
+                            <span>—</span>
+                        {/if}
+                    </div>
+                </div>
+            {/each}
         </div>
-    {/each}
+    </div>
 </div>
 
 <style>
+    .batch-items {
+        display: grid;
+        grid-template-rows: auto minmax(0, 1fr);
+        min-height: 0;
+        gap: 8px;
+    }
+
+    .capacity-summaries {
+        display: grid;
+        gap: 6px;
+    }
+
     .capacity-summary {
         display: flex;
         align-items: center;
         justify-content: space-between;
         gap: 16px;
-        margin-bottom: 10px;
-        padding: 8px 10px;
-        border: 1px solid var(--border-strong);
+        padding: 6px 8px;
+        border: 1px solid var(--color-border);
         border-radius: 6px;
         background: var(--color-panel-raised);
     }
 
     .capacity-heading,
     .record-usage,
-    .batch-table-row > div:nth-child(2) {
+    .package-cell {
         display: grid;
         gap: 3px;
     }
 
     small {
-        color: var(--text-muted);
+        color: var(--color-text-muted);
+        font-size: var(--dialog-metadata-font-size);
     }
 
     .capacity-metrics {
@@ -230,8 +248,11 @@
     }
 
     .batch-table {
+        display: grid;
+        grid-template-rows: auto minmax(0, 1fr);
+        min-height: 0;
         overflow: hidden;
-        border: 1px solid var(--border-strong);
+        border: 1px solid var(--color-border);
         border-radius: 6px;
     }
 
@@ -248,29 +269,33 @@
 
     .batch-table-header {
         align-items: center;
-        padding-block: 7px;
-        color: var(--text-muted);
+        padding-block: 6px;
+        color: var(--color-text-muted);
         background: var(--color-panel-raised);
-        font-size: 12px;
+        font-size: var(--dialog-table-header-font-size);
     }
 
     .batch-table-row {
         align-items: start;
-        padding-block: 6px;
+        padding-block: 5px;
+        font-size: var(--dialog-body-font-size);
+        line-height: 1.25;
+    }
+
+    .batch-table-rows {
+        min-height: 0;
+        overflow-y: auto;
     }
 
     .batch-table-row + .batch-table-row {
-        border-top: 1px solid var(--border-subtle);
+        border-top: 1px solid var(--color-border);
     }
 
     .selection-cell {
         display: flex;
-        align-items: center;
+        align-items: flex-start;
         justify-content: center;
-    }
-
-    .selection-cell input {
-        margin: 0;
+        padding-top: 1px;
     }
 
     .row-excluded > :not(.selection-cell) {
@@ -281,8 +306,8 @@
         display: flex;
         flex-wrap: wrap;
         gap: 2px 10px;
-        color: var(--text-muted);
-        font-size: 12px;
+        color: var(--color-text-muted);
+        font-size: var(--dialog-metadata-font-size);
     }
 
     @media (max-width: 760px) {
diff --git a/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts b/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts
index bc5920ae..fabda84e 100644
--- a/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/PackageImportDialog.test.ts
@@ -1,8 +1,13 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
 import { fireEvent, render, screen } from '@testing-library/svelte';
 import { describe, expect, it, vi } from 'vitest';
 import type { ImageSessionPackageImportPlan, PackageInspection } from '../transport';
 import PackageImportDialog from './PackageImportDialog.svelte';
 
+const appStyles = readFileSync(resolve(process.cwd(), 'src/app.css'), 'utf8');
+
 const inspection: PackageInspection = {
     schemaVersion: '1.0',
     packageId: 'package-1',
@@ -223,6 +228,12 @@ const callbacks = {
 };
 
 describe('PackageImportDialog', () => {
+    it('owns consistent spacing around the reusable destination chooser', () => {
+        expect(appStyles).toMatch(/\.package-dialog-content\s*\{[^}]*display:\s*grid;[^}]*gap:\s*12px;/s);
+        const sourceSummaryRule = appStyles.match(/\.package-source-summary\s*\{[^}]*\}/s)?.[0];
+        expect(sourceSummaryRule).not.toContain('margin-bottom');
+    });
+
     it('does not offer to replace a package that was explicitly dropped', () => {
         render(PackageImportDialog, {
             props: {
diff --git a/apps/axkdeck/src/lib/components/PlacementRepairDialog.svelte b/apps/axkdeck/src/lib/components/PlacementRepairDialog.svelte
index e7d01784..2545b555 100644
--- a/apps/axkdeck/src/lib/components/PlacementRepairDialog.svelte
+++ b/apps/axkdeck/src/lib/components/PlacementRepairDialog.svelte
@@ -187,7 +187,7 @@
 
     .placement-repair-content p {
         margin-top: 4px;
-        font-size: 11px;
+        font-size: var(--dialog-body-font-size);
     }
 
     .placement-destinations,
@@ -198,7 +198,7 @@
 
     .placement-destinations h3,
     .placement-blockers h3 {
-        font-size: 11px;
+        font-size: var(--dialog-section-font-size);
     }
 
     .placement-destination {
@@ -211,7 +211,7 @@
         border: 1px solid var(--color-border);
         border-radius: 5px;
         background: rgb(255 255 255 / 2%);
-        font-size: 10px;
+        font-size: var(--dialog-body-font-size);
     }
 
     .placement-destination > span:first-child {
@@ -233,7 +233,7 @@
         display: grid;
         gap: 5px;
         color: var(--color-text-muted);
-        font-size: 10px;
+        font-size: var(--dialog-label-font-size);
     }
 
     .recovery-volume-field input {
diff --git a/apps/axkdeck/src/lib/components/ProgramGenerationDialog.svelte b/apps/axkdeck/src/lib/components/ProgramGenerationDialog.svelte
index 33754d1f..420467a4 100644
--- a/apps/axkdeck/src/lib/components/ProgramGenerationDialog.svelte
+++ b/apps/axkdeck/src/lib/components/ProgramGenerationDialog.svelte
@@ -91,6 +91,7 @@
                     <div class="program-generation-header" role="row">
                         <span class="selection-cell" role="columnheader">
                             <input
+                                class="dialog-checkbox"
                                 type="checkbox"
                                 aria-label="Select all targets"
                                 checked={allSelected}
@@ -109,6 +110,7 @@
                             <div class:excluded={!row.selected} class="program-generation-row" role="row">
                                 <div class="selection-cell" role="cell">
                                     <input
+                                        class="dialog-checkbox"
                                         type="checkbox"
                                         aria-label={`Generate Program for ${row.targetObjectName}`}
                                         checked={row.selected}
@@ -207,7 +209,7 @@
     .program-generation-state,
     .program-generation-notices {
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-body-font-size);
     }
 
     .program-generation-state {
@@ -231,15 +233,15 @@
 
     .program-generation-header {
         align-items: center;
-        padding-block: 7px;
+        padding-block: 6px;
         color: var(--color-text-muted);
         background: var(--color-panel-raised);
-        font-size: 12px;
+        font-size: var(--dialog-table-header-font-size);
     }
 
     .program-generation-row {
         align-items: start;
-        padding-block: 6px;
+        padding-block: 5px;
     }
 
     .program-generation-row + .program-generation-row {
@@ -280,7 +282,7 @@
     .program-generation-target small,
     .program-generation-name-error {
         color: var(--color-text-muted);
-        font-size: 10px;
+        font-size: var(--dialog-metadata-font-size);
     }
 
     .program-generation-slot,
@@ -312,7 +314,7 @@
 
     .program-generation-footer > span {
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-body-font-size);
     }
 
     .program-generation-footer-actions {
diff --git a/apps/axkdeck/src/lib/components/ProgramGenerationDialog.test.ts b/apps/axkdeck/src/lib/components/ProgramGenerationDialog.test.ts
index 87fca1c9..0ee9d08b 100644
--- a/apps/axkdeck/src/lib/components/ProgramGenerationDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/ProgramGenerationDialog.test.ts
@@ -119,7 +119,7 @@ describe('ProgramGenerationDialog', () => {
             /\.program-generation-content\s*\{[^}]*grid-auto-rows:\s*max-content;[^}]*overflow:\s*auto;/s,
         );
         expect(dialogSource).toMatch(/\.program-generation-row\s*\{[^}]*align-items:\s*start;/s);
-        expect(dialogSource).toMatch(/\.program-generation-row\s*\{[^}]*padding-block:\s*6px;/s);
+        expect(dialogSource).toMatch(/\.program-generation-row\s*\{[^}]*padding-block:\s*5px;/s);
         expect(dialogSource).toMatch(/\.excluded\s*>\s*:not\(\.selection-cell\)\s*\{[^}]*opacity:\s*0\.55;/s);
         expect(dialogSource).not.toMatch(/\.program-generation-rows\s*\{[^}]*(?:max-height|overflow-y):/s);
         expect(dialogSource).toMatch(/@media \(max-width:\s*760px\)/);
diff --git a/apps/axkdeck/src/lib/components/ProgramWorkspace.svelte b/apps/axkdeck/src/lib/components/ProgramWorkspace.svelte
index 4c651d79..65554925 100644
--- a/apps/axkdeck/src/lib/components/ProgramWorkspace.svelte
+++ b/apps/axkdeck/src/lib/components/ProgramWorkspace.svelte
@@ -12,6 +12,7 @@
         updatePackageExportSelection,
         type PackageExportSelectionState,
     } from '../objectSelection';
+    import { objectSizeSummary, objectSizeTooltip } from '../objectSizePresentation';
     import type { SystemProgramContexts, SystemProgramPart } from '../transport';
     import type { ObjectRenameTarget, PackageExportObject, Program } from '../types';
     import CollectionToolbar from './CollectionToolbar.svelte';
@@ -375,12 +376,14 @@
                     class:selected={selection.items.some((item) => item.objectId === program.objectId)}
                     class="program-row"
                     data-navigation-index={index}
+                    title={objectSizeTooltip(program.object)}
                     aria-pressed={selection.items.some((item) => item.objectId === program.objectId)}
                     onclick={(event) => selectProgram(event, program)}
                     oncontextmenu={(event) => openMenu(event, program)}
                     onkeydown={(event) => navigatePrograms(event, index)}
                 >
                     <span class="object-slot">{program.slot}</span><strong>{program.name}</strong>
+                    <small class="object-size-summary">{objectSizeSummary(program.object)}</small>
                 </button>
             {:else}
                 <p class="empty-copy">No matching Programs</p>
diff --git a/apps/axkdeck/src/lib/components/ProgramWorkspace.test.ts b/apps/axkdeck/src/lib/components/ProgramWorkspace.test.ts
index 113f9a8c..2004e870 100644
--- a/apps/axkdeck/src/lib/components/ProgramWorkspace.test.ts
+++ b/apps/axkdeck/src/lib/components/ProgramWorkspace.test.ts
@@ -22,6 +22,7 @@ function program(programNumber: number, name: string): Program {
         categoryName: 'PROG',
         sfsId: programNumber,
         storedSizeBytes: 128,
+        sizeWithDependenciesBytes: null,
         sampleRate: 0,
         rootKey: 0,
         frameCount: 0,
diff --git a/apps/axkdeck/src/lib/components/SfzExportDialog.svelte b/apps/axkdeck/src/lib/components/SfzExportDialog.svelte
index 000a33c9..14861c63 100644
--- a/apps/axkdeck/src/lib/components/SfzExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/SfzExportDialog.svelte
@@ -99,19 +99,15 @@
                     <p class="dialog-progress" role="status">Inspecting audio export…</p>
                 {:else if inspection}
                     <p class="package-export-type-summary">{counts}</p>
-                    <div class="audio-export-format" role="group" aria-label="Export format">
+                    <div class="audio-export-format dialog-segmented-control" role="group" aria-label="Export format">
                         <button
-                            class:active={format === 'SFZ'}
                             type="button"
                             disabled={!inspection.sfzEligible}
                             aria-pressed={format === 'SFZ'}
                             onclick={() => onformatchange('SFZ')}>SFZ + WAV</button
                         >
-                        <button
-                            class:active={format === 'WAV'}
-                            type="button"
-                            aria-pressed={format === 'WAV'}
-                            onclick={() => onformatchange('WAV')}>WAV files</button
+                        <button type="button" aria-pressed={format === 'WAV'} onclick={() => onformatchange('WAV')}
+                            >WAV files</button
                         >
                     </div>
                     {#if inspection.sfzEligible}
diff --git a/apps/axkdeck/src/lib/components/TreeNode.svelte b/apps/axkdeck/src/lib/components/TreeNode.svelte
index 499dc212..dbde411f 100644
--- a/apps/axkdeck/src/lib/components/TreeNode.svelte
+++ b/apps/axkdeck/src/lib/components/TreeNode.svelte
@@ -1,6 +1,10 @@
 <script lang="ts">
     import { tick } from 'svelte';
+    import { formatAllocationBytes } from '../allocationInspector';
     import { hasDisallowedNavigationModifier, linearNavigationIndex } from '../collectionNavigation';
+    import { formatStoredSize } from '../formatBytes';
+    import { selectionMode, type ObjectSelectionMode } from '../objectSelection';
+    import { orderSamplerTreeItems } from '../samplerTreeOrder';
     import type { DiskTreeItem } from '../types';
     import Icon from './Icon.svelte';
     import TreeNode from './TreeNode.svelte';
@@ -8,9 +12,11 @@
     interface Props {
         item: DiskTreeItem;
         selectedId: string;
+        selectedVolumeIds?: readonly string[];
         depth?: number;
         parentId?: string;
-        onselect: (item: DiskTreeItem) => void;
+        onselect: (item: DiskTreeItem, mode: ObjectSelectionMode) => void;
+        onregister?: (item: DiskTreeItem, present: boolean) => void;
         onloadchildren: (
             parentId: string,
             offset: number,
@@ -25,15 +31,18 @@
         audioExportEnabled?: boolean;
         mediaConversionEnabled?: boolean;
         allocationInspectionEnabled?: boolean;
+        samplerOrderingEnabled?: boolean;
         onrequestmenu?: (item: DiskTreeItem, x: number, y: number) => void;
     }
 
     let {
         item,
         selectedId,
+        selectedVolumeIds = [],
         depth = 0,
         parentId = '',
         onselect,
+        onregister = () => undefined,
         onloadchildren,
         volumeActionsEnabled = false,
         partitionActionsEnabled = false,
@@ -44,6 +53,7 @@
         audioExportEnabled = false,
         mediaConversionEnabled = false,
         allocationInspectionEnabled = false,
+        samplerOrderingEnabled = false,
         onrequestmenu = () => undefined,
     }: Props = $props();
     let expanded = $state(false);
@@ -52,7 +62,10 @@
     let loading = $state(false);
     let loadError = $state('');
     let initialized = false;
+    const selected = $derived(item.kind === 'volume' ? selectedVolumeIds.includes(item.id) : selectedId === item.id);
     const hasChildren = $derived(item.kind !== 'volume' && totalCount > 0);
+    const loadCompletePartition = $derived(samplerOrderingEnabled && item.kind === 'partition');
+    const orderedChildren = $derived(loadCompletePartition ? orderSamplerTreeItems(children, 'volume') : children);
     const metadata = $derived(
         item.kind === 'partition' && item.partitionIndex !== undefined
             ? `[Partition ${item.partitionIndex}]`
@@ -60,18 +73,59 @@
               ? '[Volume]'
               : '',
     );
+    const partitionCapacity = $derived(item.kind === 'partition' ? item.partitionCapacity : undefined);
+    const usableClusters = $derived(
+        partitionCapacity ? partitionCapacity.allocatedClusters + partitionCapacity.freeClusters : 0,
+    );
+    const usedPercent = $derived(
+        partitionCapacity && usableClusters > 0
+            ? Math.min(100, Math.round((partitionCapacity.allocatedClusters / usableClusters) * 100))
+            : 0,
+    );
+    const capacityLevel = $derived(usedPercent >= 90 ? 'critical' : usedPercent >= 80 ? 'warning' : 'normal');
+    const partitionTooltipId = $derived(`partition-capacity-${item.id}`);
+    const volumeTooltipId = $derived(`volume-size-${item.id}`);
+    const tooltipId = $derived(
+        loadCompletePartition
+            ? partitionTooltipId
+            : item.kind === 'volume' && item.sizeBytes !== undefined
+              ? volumeTooltipId
+              : undefined,
+    );
+    const partitionVolumeText = $derived(`${item.childCount} ${item.childCount === 1 ? 'volume' : 'volumes'}`);
+    const partitionCapacityText = $derived(
+        partitionCapacity
+            ? `${partitionCapacity.allocatedClusters.toLocaleString()} of ${usableClusters.toLocaleString()} clusters used`
+            : 'Capacity unavailable',
+    );
+    const partitionSpaceText = $derived(
+        partitionCapacity
+            ? `${formatAllocationBytes(partitionCapacity.allocatedClusters * partitionCapacity.clusterSizeBytes)} of ${formatAllocationBytes(usableClusters * partitionCapacity.clusterSizeBytes)} used`
+            : '',
+    );
 
     function containsSelected(nodes: DiskTreeItem[]): boolean {
         return nodes.some((node) => node.id === selectedId || containsSelected(node.children ?? []));
     }
 
+    $effect(() => {
+        onregister(item, true);
+        return () => onregister(item, false);
+    });
+
     $effect(() => {
         if (initialized) return;
-        expanded = item.kind === 'disk' || item.id === selectedId || containsSelected(item.children ?? []);
+        expanded =
+            item.kind === 'disk' ||
+            loadCompletePartition ||
+            item.id === selectedId ||
+            containsSelected(item.children ?? []);
         children = item.children ?? [];
         totalCount = item.childCount;
         initialized = true;
-        if (expanded && children.length === 0 && hasChildren) void loadMore();
+        if (expanded && children.length < totalCount && (children.length === 0 || loadCompletePartition)) {
+            void loadMore();
+        }
     });
 
     async function loadMore(): Promise<void> {
@@ -79,15 +133,21 @@
         loading = true;
         loadError = '';
         try {
-            const page = await onloadchildren(item.id, children.length, 64);
-            if (!Number.isSafeInteger(page.totalCount) || page.totalCount < children.length + page.items.length) {
-                throw new Error('The server returned an invalid tree page');
-            }
-            if (page.items.length === 0 && children.length < page.totalCount) {
-                throw new Error('The server returned an incomplete tree page');
-            }
-            children = [...children, ...page.items];
-            totalCount = page.totalCount;
+            const loaded = [...children];
+            let loadedTotalCount = totalCount;
+            do {
+                const page = await onloadchildren(item.id, loaded.length, 64);
+                if (!Number.isSafeInteger(page.totalCount) || page.totalCount < loaded.length + page.items.length) {
+                    throw new Error('The server returned an invalid tree page');
+                }
+                if (page.items.length === 0 && loaded.length < page.totalCount) {
+                    throw new Error('The server returned an incomplete tree page');
+                }
+                loaded.push(...page.items);
+                loadedTotalCount = page.totalCount;
+            } while (loadCompletePartition && loaded.length < loadedTotalCount);
+            children = loaded;
+            totalCount = loadedTotalCount;
         } catch (reason) {
             loadError = reason instanceof Error ? reason.message : String(reason);
         } finally {
@@ -98,7 +158,9 @@
     async function toggle(): Promise<void> {
         if (!hasChildren) return;
         expanded = !expanded;
-        if (expanded && children.length === 0) await loadMore();
+        if (expanded && children.length < totalCount && (children.length === 0 || loadCompletePartition)) {
+            await loadMore();
+        }
     }
 
     function canOpenMenu(): boolean {
@@ -191,7 +253,8 @@
 
 <div>
     <div
-        class:selected={selectedId === item.id}
+        class:selected
+        class:partition-summary-row={loadCompletePartition}
         class="tree-row group"
         style:--tree-depth={depth}
         data-import-drop-volume={item.kind === 'volume' ? item.name : undefined}
@@ -216,27 +279,62 @@
         {:else}
             <span class="tree-chevron" aria-hidden="true"></span>
         {/if}
-        <button
-            class="tree-item-select"
-            type="button"
-            aria-current={selectedId === item.id ? 'true' : undefined}
-            data-tree-id={item.id}
-            data-tree-parent-id={parentId}
-            onclick={() => onselect(item)}
-            onkeydown={(event) => void handleTreeKeyboard(event)}
-            oncontextmenu={openContextMenu}
-        >
-            <span class:volume={item.kind === 'volume'} class="tree-icon"
-                ><Icon
-                    name={item.kind === 'disk' ? 'disc' : item.kind === 'object' ? 'waveform' : 'folder'}
-                    size={14}
-                /></span
+        <div class="tree-item-stack">
+            <button
+                class="tree-item-select"
+                type="button"
+                aria-current={selectedId === item.id ? 'true' : undefined}
+                aria-pressed={item.kind === 'volume' ? selected : undefined}
+                aria-describedby={tooltipId}
+                data-tree-id={item.id}
+                data-tree-kind={item.kind}
+                data-tree-parent-id={parentId}
+                onclick={(event) => onselect(item, selectionMode(event))}
+                ondblclick={() => {
+                    if (item.kind === 'partition') void toggle();
+                }}
+                onkeydown={(event) => void handleTreeKeyboard(event)}
+                oncontextmenu={openContextMenu}
             >
-            <span class="tree-item-name" style:white-space="pre">{item.name}</span>
-            {#if metadata}<span class="tree-item-metadata">{metadata}</span>{/if}
-            {#if item.kind === 'disk'}<span class="size-1.5 rounded-full bg-emerald-400 shadow-[0_0_8px_#34d399]"
-                ></span>{/if}
-        </button>
+                <span class:volume={item.kind === 'volume'} class="tree-icon"
+                    ><Icon
+                        name={item.kind === 'disk' ? 'disc' : item.kind === 'object' ? 'waveform' : 'folder'}
+                        size={14}
+                    /></span
+                >
+                <span class="tree-item-name" style:white-space="pre">{item.name}</span>
+                {#if metadata}<span class="tree-item-metadata">{metadata}</span>{/if}
+                {#if item.kind === 'disk'}<span class="size-1.5 rounded-full bg-emerald-400 shadow-[0_0_8px_#34d399]"
+                    ></span>{/if}
+            </button>
+            {#if loadCompletePartition}
+                {#if partitionCapacity}
+                    <span
+                        class:warning={capacityLevel === 'warning'}
+                        class:critical={capacityLevel === 'critical'}
+                        class="partition-capacity"
+                        role="progressbar"
+                        aria-label={`${usedPercent}% used`}
+                        aria-valuemin="0"
+                        aria-valuemax="100"
+                        aria-valuenow={usedPercent}
+                    >
+                        <span class="partition-capacity-fill" style:width={`${usedPercent}%`}></span>
+                    </span>
+                {:else}
+                    <span class="partition-capacity unavailable" aria-hidden="true"></span>
+                {/if}
+                <span id={partitionTooltipId} class="tree-item-tooltip" role="tooltip">
+                    <span>{partitionVolumeText}</span>
+                    <span>{partitionCapacityText}</span>
+                    {#if partitionSpaceText}<span>{partitionSpaceText}</span>{/if}
+                </span>
+            {:else if item.kind === 'volume' && item.sizeBytes !== undefined}
+                <span id={volumeTooltipId} class="tree-item-tooltip" role="tooltip">
+                    <span>Size: {formatStoredSize(item.sizeBytes)}</span>
+                </span>
+            {/if}
+        </div>
     </div>
 
     {#if expanded && hasChildren}
@@ -247,13 +345,15 @@
                     <button type="button" onclick={() => void loadMore()}>Retry</button>
                 </div>
             {/if}
-            {#each children as child (child.id)}
+            {#each orderedChildren as child (child.id)}
                 <TreeNode
                     item={child}
                     {selectedId}
+                    {selectedVolumeIds}
                     depth={depth + 1}
                     parentId={item.id}
                     {onselect}
+                    {onregister}
                     {onloadchildren}
                     {volumeActionsEnabled}
                     {partitionActionsEnabled}
@@ -264,6 +364,7 @@
                     {audioExportEnabled}
                     {mediaConversionEnabled}
                     {allocationInspectionEnabled}
+                    {samplerOrderingEnabled}
                     {onrequestmenu}
                 />
             {/each}
@@ -282,3 +383,96 @@
         </div>
     {/if}
 </div>
+
+<style>
+    .tree-row {
+        position: relative;
+    }
+
+    .partition-summary-row {
+        height: 27px;
+    }
+
+    .partition-summary-row > .tree-chevron {
+        align-self: flex-start;
+        margin-top: 4px;
+    }
+
+    .tree-item-stack {
+        position: relative;
+        min-width: 0;
+        height: 100%;
+        flex: 1;
+    }
+
+    .tree-item-stack > .tree-item-select {
+        width: 100%;
+        height: 100%;
+    }
+
+    .partition-summary-row .tree-item-select {
+        box-sizing: border-box;
+        padding-bottom: 6px;
+    }
+
+    .partition-capacity {
+        position: absolute;
+        left: 0;
+        right: 0;
+        bottom: 1px;
+        height: 3px;
+        overflow: hidden;
+        border-radius: 1px;
+        background: var(--color-border);
+        pointer-events: none;
+    }
+
+    .partition-capacity.unavailable {
+        border-bottom: 1px dashed var(--color-border);
+        background: transparent;
+        opacity: 0.55;
+    }
+
+    .partition-capacity-fill {
+        display: block;
+        height: 100%;
+        background: var(--color-accent);
+    }
+
+    .partition-capacity.warning .partition-capacity-fill {
+        background: var(--color-brand);
+    }
+
+    .partition-capacity.critical .partition-capacity-fill {
+        background: var(--color-danger);
+    }
+
+    .tree-item-tooltip {
+        position: absolute;
+        z-index: 70;
+        top: calc(100% + 3px);
+        right: 4px;
+        display: grid;
+        width: max-content;
+        max-width: 230px;
+        gap: 2px;
+        padding: 6px 8px;
+        color: var(--color-text);
+        border: 1px solid var(--color-border);
+        border-radius: 5px;
+        background: var(--color-panel-raised);
+        box-shadow: 0 8px 20px rgb(0 0 0 / 35%);
+        opacity: 0;
+        pointer-events: none;
+        transform: translateY(-2px);
+        transition:
+            opacity 100ms ease,
+            transform 100ms ease;
+    }
+
+    .tree-row:hover > .tree-item-stack > .tree-item-tooltip,
+    .tree-item-select:focus-visible ~ .tree-item-tooltip {
+        opacity: 1;
+        transform: translateY(0);
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/components/TreeNode.test.ts b/apps/axkdeck/src/lib/components/TreeNode.test.ts
index 8d431c21..7ffb257f 100644
--- a/apps/axkdeck/src/lib/components/TreeNode.test.ts
+++ b/apps/axkdeck/src/lib/components/TreeNode.test.ts
@@ -1,7 +1,14 @@
+/// <reference types="node" />
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
 import { fireEvent, render, screen, waitFor } from '@testing-library/svelte';
 import { describe, expect, it, vi } from 'vitest';
 import TreeNode from './TreeNode.svelte';
 
+const treeNodeSource = readFileSync(resolve(process.cwd(), 'src/lib/components/TreeNode.svelte'), 'utf8');
+
 describe('TreeNode', () => {
     it('uses conventional tree arrow navigation and selects the focused row', async () => {
         const partition = {
@@ -23,11 +30,11 @@ describe('TreeNode', () => {
         partitionButton.focus();
         await fireEvent.keyDown(partitionButton, { key: 'ArrowRight' });
         expect(screen.getByRole('button', { name: /Piano \[Volume/ })).toBe(document.activeElement);
-        expect(onselect).toHaveBeenLastCalledWith(partition.children[0]);
+        expect(onselect).toHaveBeenLastCalledWith(partition.children[0], 'replace');
 
         await fireEvent.keyDown(document.activeElement as HTMLElement, { key: 'ArrowDown' });
         expect(screen.getByRole('button', { name: /Strings \[Volume/ })).toBe(document.activeElement);
-        expect(onselect).toHaveBeenLastCalledWith(partition.children[1]);
+        expect(onselect).toHaveBeenLastCalledWith(partition.children[1], 'replace');
 
         await fireEvent.keyDown(document.activeElement as HTMLElement, { key: 'Home' });
         expect(partitionButton).toBe(document.activeElement);
@@ -36,7 +43,7 @@ describe('TreeNode', () => {
 
         await fireEvent.keyDown(document.activeElement as HTMLElement, { key: 'ArrowLeft' });
         expect(partitionButton).toBe(document.activeElement);
-        expect(onselect).toHaveBeenLastCalledWith(partition);
+        expect(onselect).toHaveBeenLastCalledWith(partition, 'replace');
 
         await fireEvent.keyDown(partitionButton, { key: 'ArrowLeft' });
         expect(screen.queryByRole('button', { name: /Piano \[Volume/ })).toBeNull();
@@ -67,6 +74,222 @@ describe('TreeNode', () => {
         expect(screen.getByRole('button', { name: /Volume α \[Volume/ })).toBe(document.activeElement);
     });
 
+    it('loads every volume page before rendering sampler display order', async () => {
+        const onloadchildren = vi
+            .fn()
+            .mockResolvedValueOnce({
+                items: [
+                    { id: 'v-dollar', name: '$foo', kind: 'volume', childCount: 0 },
+                    { id: 'v-a', name: 'a_foo', kind: 'volume', childCount: 0 },
+                ],
+                totalCount: 5,
+            })
+            .mockResolvedValueOnce({
+                items: [
+                    { id: 'v-number', name: '001_foo', kind: 'volume', childCount: 0 },
+                    { id: 'v-c', name: 'c_foo', kind: 'volume', childCount: 0 },
+                ],
+                totalCount: 5,
+            })
+            .mockResolvedValueOnce({
+                items: [{ id: 'v-bang', name: '!foo', kind: 'volume', childCount: 0 }],
+                totalCount: 5,
+            });
+        const { container } = render(TreeNode, {
+            props: {
+                item: { id: 'p0', name: 'Partition 0', kind: 'partition', childCount: 5 },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren,
+                samplerOrderingEnabled: true,
+            },
+        });
+
+        await waitFor(() => expect(screen.getByText('!foo')).toBeTruthy());
+        expect(onloadchildren).toHaveBeenNthCalledWith(1, 'p0', 0, 64);
+        expect(onloadchildren).toHaveBeenNthCalledWith(2, 'p0', 2, 64);
+        expect(onloadchildren).toHaveBeenNthCalledWith(3, 'p0', 4, 64);
+        expect([...container.querySelectorAll('.tree-item-name')].map((name) => name.textContent)).toEqual([
+            'Partition 0',
+            '!foo',
+            '$foo',
+            '001_foo',
+            'a_foo',
+            'c_foo',
+        ]);
+        expect(screen.queryByRole('button', { name: /Load more/ })).toBeNull();
+    });
+
+    it('completes a partially embedded SFS volume list when its partition opens', async () => {
+        const onloadchildren = vi.fn().mockResolvedValue({
+            items: [{ id: 'v-bang', name: '!foo', kind: 'volume', childCount: 0 }],
+            totalCount: 2,
+        });
+        const { container } = render(TreeNode, {
+            props: {
+                item: {
+                    id: 'p0',
+                    name: 'Partition 0',
+                    kind: 'partition',
+                    childCount: 2,
+                    children: [{ id: 'v-a', name: 'a_foo', kind: 'volume', childCount: 0 }],
+                },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren,
+                samplerOrderingEnabled: true,
+            },
+        });
+
+        await waitFor(() => expect(screen.getByText('!foo')).toBeTruthy());
+        expect(onloadchildren).toHaveBeenCalledWith('p0', 1, 64);
+        expect([...container.querySelectorAll('.tree-item-name')].map((name) => name.textContent)).toEqual([
+            'Partition 0',
+            '!foo',
+            'a_foo',
+        ]);
+    });
+
+    it('toggles an SFS partition when its row is double-clicked', async () => {
+        render(TreeNode, {
+            props: {
+                item: {
+                    id: 'p0',
+                    name: 'Partition 0',
+                    kind: 'partition',
+                    childCount: 1,
+                    children: [{ id: 'v0', name: 'Volume 0', kind: 'volume', childCount: 0 }],
+                },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren: vi.fn(),
+                samplerOrderingEnabled: true,
+            },
+        });
+
+        const partition = screen.getByRole('button', { name: 'Partition 0' });
+        expect(screen.getByRole('button', { name: /Volume 0 \[Volume/ })).toBeTruthy();
+
+        await fireEvent.dblClick(partition);
+        expect(screen.queryByRole('button', { name: /Volume 0 \[Volume/ })).toBeNull();
+
+        await fireEvent.dblClick(partition);
+        expect(screen.getByRole('button', { name: /Volume 0 \[Volume/ })).toBeTruthy();
+    });
+
+    it('shows partition volume and usable-capacity details with warning thresholds', () => {
+        const { container } = render(TreeNode, {
+            props: {
+                item: {
+                    id: 'p0',
+                    name: 'Partition 0',
+                    kind: 'partition',
+                    childCount: 3,
+                    partitionCapacity: {
+                        allocatedClusters: 80,
+                        freeClusters: 20,
+                        clusterSizeBytes: 1024,
+                    },
+                },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren: vi.fn().mockResolvedValue({ items: [], totalCount: 0 }),
+                samplerOrderingEnabled: true,
+            },
+        });
+
+        const capacity = screen.getByRole('progressbar', { name: '80% used' });
+        const partitionRow = capacity.closest('.tree-row');
+        const partitionStack = capacity.closest('.tree-item-stack');
+        expect(capacity.getAttribute('aria-valuenow')).toBe('80');
+        expect(capacity.getAttribute('aria-valuemax')).toBe('100');
+        expect(capacity.classList.contains('warning')).toBe(true);
+        expect(partitionRow?.classList.contains('partition-summary-row')).toBe(true);
+        expect(partitionStack).toBeTruthy();
+        expect(partitionStack?.querySelector('.tree-item-name')?.textContent).toBe('Partition 0');
+        expect(partitionStack?.querySelector('.partition-capacity')).toBe(capacity);
+        expect(container.querySelector('[role="tooltip"]')?.textContent).toContain('3 volumes');
+        expect(container.querySelector('[role="tooltip"]')?.textContent).toContain('80 of 100 clusters used');
+        expect(container.querySelector('[role="tooltip"]')?.textContent).toContain('80 KiB of 100 KiB used');
+    });
+
+    it('renders SFS capacity as a slim full-width second line without narrowing the partition name', () => {
+        expect(treeNodeSource).toMatch(/\.partition-summary-row\s*\{[^}]*height:\s*27px/s);
+        expect(treeNodeSource).toMatch(
+            /\.partition-capacity\s*\{[^}]*position:\s*absolute[^}]*left:\s*0[^}]*right:\s*0[^}]*bottom:\s*1px[^}]*height:\s*3px/s,
+        );
+        expect(treeNodeSource).not.toContain('width: 42px');
+    });
+
+    it('marks partitions at ninety percent usage as critical', () => {
+        render(TreeNode, {
+            props: {
+                item: {
+                    id: 'p0',
+                    name: 'Partition 0',
+                    kind: 'partition',
+                    childCount: 1,
+                    partitionCapacity: {
+                        allocatedClusters: 90,
+                        freeClusters: 10,
+                        clusterSizeBytes: 1024,
+                    },
+                },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren: vi.fn().mockResolvedValue({ items: [], totalCount: 0 }),
+                samplerOrderingEnabled: true,
+            },
+        });
+
+        expect(screen.getByRole('progressbar', { name: '90% used' }).classList.contains('critical')).toBe(true);
+    });
+
+    it('keeps partition capacity alignment when the summary is unavailable', () => {
+        const { container } = render(TreeNode, {
+            props: {
+                item: { id: 'p0', name: 'Partition 0', kind: 'partition', childCount: 2 },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren: vi.fn().mockResolvedValue({ items: [], totalCount: 0 }),
+                samplerOrderingEnabled: true,
+            },
+        });
+
+        expect(screen.queryByRole('progressbar')).toBeNull();
+        expect(container.querySelector('.partition-capacity.unavailable')).toBeTruthy();
+        expect(container.querySelector('[role="tooltip"]')?.textContent).toContain('2 volumes');
+        expect(container.querySelector('[role="tooltip"]')?.textContent).toContain('Capacity unavailable');
+    });
+
+    it('hides capacity affordances for non-SFS partitions', () => {
+        const { container } = render(TreeNode, {
+            props: {
+                item: {
+                    id: 'p0',
+                    name: 'Partition 0',
+                    kind: 'partition',
+                    childCount: 2,
+                    partitionCapacity: {
+                        allocatedClusters: 80,
+                        freeClusters: 20,
+                        clusterSizeBytes: 1024,
+                    },
+                },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren: vi.fn().mockResolvedValue({ items: [], totalCount: 0 }),
+                samplerOrderingEnabled: false,
+            },
+        });
+
+        expect(screen.queryByRole('progressbar')).toBeNull();
+        expect(container.querySelector('.partition-capacity')).toBeNull();
+        expect(container.querySelector('.partition-summary-row')).toBeNull();
+        expect(container.querySelector('[role="tooltip"]')).toBeNull();
+        expect(screen.getByRole('button', { name: 'Partition 0' }).getAttribute('aria-describedby')).toBeNull();
+    });
+
     it('treats volumes as terminal browser entries even when they contain objects', () => {
         const onloadchildren = vi.fn();
         render(TreeNode, {
@@ -82,6 +305,28 @@ describe('TreeNode', () => {
         expect(onloadchildren).not.toHaveBeenCalled();
     });
 
+    it('shows a compact volume size tooltip without adding a capacity bar', () => {
+        const { container } = render(TreeNode, {
+            props: {
+                item: { id: 'v0', name: 'Strings', kind: 'volume', childCount: 12, sizeBytes: 1_572_864 },
+                selectedId: '',
+                onselect: vi.fn(),
+                onloadchildren: vi.fn(),
+            },
+        });
+
+        const volume = screen.getByRole('button', { name: 'Strings [Volume]' });
+        const tooltip = screen.getByRole('tooltip');
+        expect(tooltip.textContent).toContain('Size: 1.5 MiB');
+        expect(volume.getAttribute('aria-describedby')).toBe(tooltip.id);
+        expect(container.querySelector('.partition-capacity')).toBeNull();
+    });
+
+    it('does not keep a tooltip visible merely because a pointer-selected row retains focus', () => {
+        expect(treeNodeSource).not.toContain('.tree-row:focus-within > .tree-item-tooltip');
+        expect(treeNodeSource).toContain('.tree-item-select:focus-visible ~ .tree-item-tooltip');
+    });
+
     it('opens volume actions from pointer and keyboard context requests', async () => {
         const onrequestmenu = vi.fn();
         render(TreeNode, {
@@ -109,6 +354,28 @@ describe('TreeNode', () => {
         expect(onrequestmenu).toHaveBeenCalledTimes(2);
     });
 
+    it('reports conventional modifier selection modes for volume rows', async () => {
+        const onselect = vi.fn();
+        render(TreeNode, {
+            props: {
+                item: { id: 'v0', name: 'Strings', kind: 'volume', childCount: 0 },
+                selectedId: '',
+                selectedVolumeIds: ['v0'],
+                onselect,
+                onloadchildren: vi.fn(),
+            },
+        });
+
+        const item = screen.getByRole('button', { name: 'Strings [Volume]' });
+        expect(item.getAttribute('aria-pressed')).toBe('true');
+        await fireEvent.click(item, { ctrlKey: true });
+        expect(onselect).toHaveBeenLastCalledWith(expect.objectContaining({ id: 'v0' }), 'toggle');
+        await fireEvent.click(item, { shiftKey: true });
+        expect(onselect).toHaveBeenLastCalledWith(expect.objectContaining({ id: 'v0' }), 'range');
+        await fireEvent.click(item, { shiftKey: true, metaKey: true });
+        expect(onselect).toHaveBeenLastCalledWith(expect.objectContaining({ id: 'v0' }), 'add-range');
+    });
+
     it('shows a retry action when lazy loading fails and preserves recovery', async () => {
         const onloadchildren = vi
             .fn()
diff --git a/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte b/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte
index e41bb08c..eab9bedf 100644
--- a/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/Tx16wImportDialog.svelte
@@ -366,7 +366,7 @@
     .import-mode legend {
         padding: 0 4px;
         color: var(--color-text-muted);
-        font-size: 12px;
+        font-size: var(--dialog-label-font-size);
     }
 
     .import-mode label,
@@ -386,7 +386,7 @@
     summary span,
     .tx16w-footer > span {
         color: var(--color-text-muted);
-        font-size: 12px;
+        font-size: var(--dialog-metadata-font-size);
     }
 
     .target-field > span {
@@ -477,7 +477,7 @@
         gap: 10px;
         padding: 7px 10px;
         border-top: 1px solid rgb(61 68 72 / 65%);
-        font-size: 13px;
+        font-size: var(--dialog-body-font-size);
     }
 
     .mapping-notice.notice-blocked,
diff --git a/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte b/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte
index 6088363e..19ce19c0 100644
--- a/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte
+++ b/apps/axkdeck/src/lib/components/VolumeActionDialog.svelte
@@ -5,7 +5,7 @@
 
     interface Props {
         action: ImageTreeAction;
-        item: DiskTreeItem;
+        items: DiskTreeItem[];
         busy: boolean;
         phase: 'idle' | 'checking' | 'submitting';
         error: string;
@@ -14,9 +14,21 @@
         onsubmit: (name: string) => void;
     }
 
-    let { action, item, busy, phase, error, deletionInspection, oncancel, onsubmit }: Props = $props();
+    let { action, items, busy, phase, error, deletionInspection, oncancel, onsubmit }: Props = $props();
     let value = $state('');
     let initialized = false;
+    const item = $derived(items[0]!);
+    const deletingMultiple = $derived(action === 'delete-volume' && items.length > 1);
+    const deletionTargetGroups = $derived.by(() => {
+        const groups = new Map<number, DiskTreeItem[]>();
+        for (const target of items) {
+            const partitionIndex = target.partitionIndex ?? 0;
+            const targets = groups.get(partitionIndex) ?? [];
+            targets.push(target);
+            groups.set(partitionIndex, targets);
+        }
+        return [...groups].map(([partitionIndex, targets]) => ({ partitionIndex, targets }));
+    });
 
     $effect(() => {
         if (initialized) return;
@@ -31,7 +43,9 @@
               ? 'Rename volume'
               : action === 'rename-partition'
                 ? 'Rename partition'
-                : 'Delete volume',
+                : deletingMultiple
+                  ? `Delete ${items.length} volumes`
+                  : 'Delete volume',
     );
     const subject = $derived(action === 'rename-partition' ? 'Partition' : 'Volume');
     const submitLabel = $derived(
@@ -40,7 +54,9 @@
                 ? 'Adding'
                 : action === 'rename-volume' || action === 'rename-partition'
                   ? 'Renaming'
-                  : 'Deleting'
+                  : deletingMultiple
+                    ? `Deleting ${items.length} volumes`
+                    : 'Deleting'
             : action === 'add-volume'
               ? 'Add'
               : action === 'rename-volume' || action === 'rename-partition'
@@ -81,8 +97,26 @@
             </header>
             <div class="volume-action-content">
                 {#if action === 'delete-volume'}
-                    <strong>Permanently delete “{item.name}”?</strong>
-                    <p>The volume and all objects it contains will be destroyed. This action cannot be undone.</p>
+                    {#if deletingMultiple}
+                        <strong>Permanently delete {items.length} volumes?</strong>
+                        <p>The selected volumes and all objects they contain will be destroyed.</p>
+                        <div class="volume-deletion-targets">
+                            {#each deletionTargetGroups as group (group.partitionIndex)}
+                                <section>
+                                    <h3>Partition {group.partitionIndex + 1}</h3>
+                                    <ul>
+                                        {#each group.targets as target (target.id)}
+                                            <li>{target.name}</li>
+                                        {/each}
+                                    </ul>
+                                </section>
+                            {/each}
+                        </div>
+                    {:else}
+                        <strong>Permanently delete “{item.name}”?</strong>
+                        <p>The volume and all objects it contains will be destroyed.</p>
+                    {/if}
+                    <p>This action cannot be undone.</p>
                     {#if phase === 'checking' && !deletionInspection}
                         <p role="status">Checking object relationships…</p>
                     {:else if deletionInspection && !deletionInspection.canDelete}
@@ -123,3 +157,24 @@
         </form>
     </div>
 </div>
+
+<style>
+    .volume-deletion-targets {
+        max-height: 12rem;
+        overflow: auto;
+    }
+
+    .volume-deletion-targets section + section {
+        margin-top: 0.75rem;
+    }
+
+    .volume-deletion-targets h3 {
+        margin: 0;
+        font-size: var(--font-size-value);
+    }
+
+    .volume-deletion-targets ul {
+        margin: 0.25rem 0 0;
+        padding-left: 1.25rem;
+    }
+</style>
diff --git a/apps/axkdeck/src/lib/components/VolumeActionDialog.test.ts b/apps/axkdeck/src/lib/components/VolumeActionDialog.test.ts
index 2c3981f9..aef76bf5 100644
--- a/apps/axkdeck/src/lib/components/VolumeActionDialog.test.ts
+++ b/apps/axkdeck/src/lib/components/VolumeActionDialog.test.ts
@@ -14,8 +14,7 @@ const volume = {
 const safeDeletion = {
     imageId: 'image-1',
     revision: 1,
-    partitionIndex: 2,
-    volumeName: 'ORIGINAL',
+    targets: [{ partitionIndex: 2, volumeName: 'ORIGINAL' }],
     canDelete: true,
     crossingRelationshipCount: 0,
     blockers: [],
@@ -26,7 +25,7 @@ describe('VolumeActionDialog', () => {
         render(VolumeActionDialog, {
             props: {
                 action: 'add-volume',
-                item: { ...volume, kind: 'partition' },
+                items: [{ ...volume, kind: 'partition' }],
                 busy: true,
                 phase: 'submitting',
                 error: '',
@@ -46,7 +45,7 @@ describe('VolumeActionDialog', () => {
         render(VolumeActionDialog, {
             props: {
                 action: 'add-volume',
-                item: { ...volume, kind: 'partition' },
+                items: [{ ...volume, kind: 'partition' }],
                 busy: false,
                 phase: 'idle',
                 error: '',
@@ -69,7 +68,7 @@ describe('VolumeActionDialog', () => {
         render(VolumeActionDialog, {
             props: {
                 action: 'delete-volume',
-                item: volume,
+                items: [volume],
                 busy: false,
                 phase: 'idle',
                 error: '',
@@ -90,7 +89,7 @@ describe('VolumeActionDialog', () => {
         render(VolumeActionDialog, {
             props: {
                 action: 'delete-volume',
-                item: volume,
+                items: [volume],
                 busy: false,
                 phase: 'idle',
                 error: '',
@@ -110,12 +109,40 @@ describe('VolumeActionDialog', () => {
         expect(screen.queryByRole('button', { name: 'Repair placement' })).toBeNull();
     });
 
+    it('lists every target in a multi-volume deletion confirmation', () => {
+        const second = { ...volume, id: 'volume-2', name: 'SECOND', partitionIndex: 5 };
+        render(VolumeActionDialog, {
+            props: {
+                action: 'delete-volume',
+                items: [volume, second],
+                busy: false,
+                phase: 'idle',
+                error: '',
+                deletionInspection: {
+                    ...safeDeletion,
+                    targets: [
+                        { partitionIndex: 2, volumeName: 'ORIGINAL' },
+                        { partitionIndex: 5, volumeName: 'SECOND' },
+                    ],
+                },
+                oncancel: vi.fn(),
+                onsubmit: vi.fn(),
+            },
+        });
+
+        expect(screen.getByRole('dialog', { name: 'Delete 2 volumes' })).toBeTruthy();
+        expect(screen.getByRole('heading', { name: 'Partition 3' })).toBeTruthy();
+        expect(screen.getByText('ORIGINAL')).toBeTruthy();
+        expect(screen.getByRole('heading', { name: 'Partition 6' })).toBeTruthy();
+        expect(screen.getByText('SECOND')).toBeTruthy();
+    });
+
     it('validates and submits partition renames with the same naming rules as volumes', async () => {
         const onsubmit = vi.fn();
         render(VolumeActionDialog, {
             props: {
                 action: 'rename-partition',
-                item: { ...volume, id: 'partition-2', name: 'PARTITION 3', kind: 'partition' },
+                items: [{ ...volume, id: 'partition-2', name: 'PARTITION 3', kind: 'partition' }],
                 busy: false,
                 phase: 'idle',
                 error: '',
diff --git a/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte b/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte
index b84e9444..b993e801 100644
--- a/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte
+++ b/apps/axkdeck/src/lib/components/VolumeFloppyExportDialog.svelte
@@ -91,6 +91,6 @@
     .volume-blocker {
         margin: -5px 6px 3px;
         color: var(--color-danger-text);
-        font-size: 11px;
+        font-size: var(--dialog-body-font-size);
     }
 </style>
diff --git a/apps/axkdeck/src/lib/components/WaveDataCleanupDialog.svelte b/apps/axkdeck/src/lib/components/WaveDataCleanupDialog.svelte
index ca1b3804..c4370f4a 100644
--- a/apps/axkdeck/src/lib/components/WaveDataCleanupDialog.svelte
+++ b/apps/axkdeck/src/lib/components/WaveDataCleanupDialog.svelte
@@ -94,7 +94,7 @@
                 <label class="wave-data-cleanup-select-all">
                     <input
                         bind:this={selectAllCheckbox}
-                        class="deletion-checkbox"
+                        class="dialog-checkbox"
                         type="checkbox"
                         checked={allSelected}
                         disabled={loading || busy}
@@ -112,7 +112,7 @@
                     {#each candidates as candidate (candidate.objectId)}
                         <label class="wave-data-cleanup-row">
                             <input
-                                class="deletion-checkbox"
+                                class="dialog-checkbox"
                                 type="checkbox"
                                 checked={selectedIds.has(candidate.objectId)}
                                 disabled={loading || busy}
@@ -238,7 +238,7 @@
 
     .wave-data-cleanup-copy small,
     .wave-data-cleanup-limit {
-        font-size: 11px;
+        font-size: var(--dialog-metadata-font-size);
     }
 
     .wave-data-cleanup-empty {
@@ -267,7 +267,7 @@
 
     .wave-data-cleanup-footer-summary span {
         color: var(--color-text-muted);
-        font-size: 11px;
+        font-size: var(--dialog-metadata-font-size);
     }
 
     .wave-data-cleanup-actions {
diff --git a/apps/axkdeck/src/lib/components/WorkspaceGuard.svelte b/apps/axkdeck/src/lib/components/WorkspaceGuard.svelte
new file mode 100644
index 00000000..c6eea750
--- /dev/null
+++ b/apps/axkdeck/src/lib/components/WorkspaceGuard.svelte
@@ -0,0 +1,17 @@
+<script lang="ts">
+    interface Props {
+        enabled: boolean;
+        open: boolean;
+        activeWorkspaceId: string | null;
+    }
+
+    let { enabled, open = $bindable(), activeWorkspaceId }: Props = $props();
+    const workspaceManagerModule = import('./WorkspaceManager.svelte');
+</script>
+
+{#if enabled}
+    {#await workspaceManagerModule then workspaceManager}
+        {@const WorkspaceManager = workspaceManager.default}
+        <WorkspaceManager {open} {activeWorkspaceId} onclose={() => (open = false)} />
+    {/await}
+{/if}
diff --git a/apps/axkdeck/src/lib/components/WorkspaceManager.svelte b/apps/axkdeck/src/lib/components/WorkspaceManager.svelte
index 51bf4678..f67641d9 100644
--- a/apps/axkdeck/src/lib/components/WorkspaceManager.svelte
+++ b/apps/axkdeck/src/lib/components/WorkspaceManager.svelte
@@ -333,7 +333,8 @@
                         /></label
                     >
                     <label class="workspace-toggle"
-                        ><input type="checkbox" bind:checked={writable} /> Allow image creation and changes</label
+                        ><input class="dialog-checkbox" type="checkbox" bind:checked={writable} /> Allow image creation and
+                        changes</label
                     >
                     {#if error}<p class="workspace-error" role="alert">{error}</p>{/if}
                 </div>
@@ -405,15 +406,15 @@
         gap: 0;
     }
     .workspace-row strong {
-        font-size: 10px;
+        font-size: var(--dialog-body-font-size);
         line-height: 11px;
     }
     .workspace-row small {
         display: block;
         margin: 0;
         color: var(--color-text-muted);
-        font-size: 8px;
-        line-height: 9px;
+        font-size: var(--dialog-metadata-font-size);
+        line-height: 1.2;
     }
     .host-row {
         min-height: 36px;
@@ -457,7 +458,7 @@
         display: grid;
         gap: 4px;
         color: var(--color-text-muted);
-        font-size: 10px;
+        font-size: var(--dialog-label-font-size);
     }
     .workspace-form input[type='text'] {
         width: 100%;
diff --git a/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts b/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts
index b23026e6..1f34367b 100644
--- a/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts
+++ b/apps/axkdeck/src/lib/components/WorkspaceManager.test.ts
@@ -111,7 +111,7 @@ describe('WorkspaceManager', () => {
         const status = rows[0].querySelector('small');
         expect(status).not.toBeNull();
         expect(getComputedStyle(name).lineHeight).toBe('11px');
-        expect(getComputedStyle(status!).lineHeight).toBe('9px');
+        expect(getComputedStyle(status!).lineHeight).toBe('1.2');
         expect(getComputedStyle(status!).marginTop).toBe('0px');
 
         style.remove();
diff --git a/apps/axkdeck/src/lib/createTransport.ts b/apps/axkdeck/src/lib/createTransport.ts
index 5db0105d..6989decb 100644
--- a/apps/axkdeck/src/lib/createTransport.ts
+++ b/apps/axkdeck/src/lib/createTransport.ts
@@ -207,7 +207,7 @@ class UnavailableTransport implements ImageTransport {
     closeImage(): Promise<void> {
         return Promise.resolve();
     }
-    startVolumeMutation(): Promise<JobState> {
+    startVolumeMutations(): Promise<JobState> {
         return this.unavailable();
     }
     startPartitionMutation(): Promise<JobState> {
diff --git a/apps/axkdeck/src/lib/generated/axklibApiV1.ts b/apps/axkdeck/src/lib/generated/axklibApiV1.ts
index 9d02a17b..2dc28a57 100644
--- a/apps/axkdeck/src/lib/generated/axklibApiV1.ts
+++ b/apps/axkdeck/src/lib/generated/axklibApiV1.ts
@@ -2198,6 +2198,7 @@ export interface components {
             objectId: string | null;
             objectType: string | null;
             parentId: string | null;
+            partitionCapacity: components['schemas']['ImagePartitionCapacity'] | null;
             partitionIndex: number | null;
             quality: string;
             /**
@@ -2205,6 +2206,8 @@ export interface components {
              * @enum {string}
              */
             scopeRole: 'CONTAINED' | 'REFERENCE';
+            /** @description Deduplicated stored size of objects contained by a volume; null for other content nodes or when unavailable. */
+            sizeBytes: number | null;
             volumeDirectoryId: number | null;
         };
         ImageContentPage: {
@@ -2247,8 +2250,9 @@ export interface components {
             partitionName: string;
             prerequisiteObjectIds: string[];
             reason: string;
+            requested: boolean;
             /** @enum {unknown} */
-            role: 'TARGET' | 'DEPENDENCY';
+            role: 'TARGET' | 'REFERRER' | 'DEPENDENCY';
             selected: boolean;
             /** @enum {unknown} */
             status: 'REQUIRED' | 'OPTIONAL' | 'PRESERVED' | 'BLOCKED';
@@ -2259,6 +2263,7 @@ export interface components {
             blockers: components['schemas']['ImageObjectDeletionNotice'][];
             /** @description True when at least one requested object can be deleted safely */
             canApply: boolean;
+            cleanupObjectIds: string[];
             /** @description Allocated storage bytes expected to become free for the selected deletion closure */
             estimatedFreedBytes: number;
             /** @description Allocated storage clusters expected to become free for the selected deletion closure */
@@ -2266,6 +2271,7 @@ export interface components {
             imageId: string;
             impacts: components['schemas']['ImageObjectDeletionImpact'][];
             references: components['schemas']['ImageObjectDeletionReference'][];
+            referrerObjectIds: string[];
             revision: number;
             selectedObjectIds: string[];
             targetObjectIds: string[];
@@ -2293,6 +2299,7 @@ export interface components {
             cleanupObjectIds: string[];
             expectedRevision: number;
             imageId: string;
+            referrerObjectIds: string[];
             targetObjectIds: string[];
         };
         ImageObjectDeletionResult: {
@@ -2324,6 +2331,8 @@ export interface components {
             sequence: components['schemas']['SequenceMetadata'] | null;
             /** @description Complete stored object file or record size, including object metadata and stored payload bytes. */
             sizeBytes: number;
+            /** @description Deduplicated stored size of this Program, Sample Bank, or Sample and its exact forward dependency closure; null when the closure is unavailable. */
+            sizeWithDependenciesBytes: number | null;
             type: string;
             volumeName: string;
             waveform: components['schemas']['WaveDataMetadata'] | null;
@@ -2340,6 +2349,11 @@ export interface components {
         ImageOpenRequest: {
             source: components['schemas']['ImageSourceRef'];
         };
+        ImagePartitionCapacity: {
+            allocatedClusters: number;
+            clusterSizeBytes: number;
+            freeClusters: number;
+        };
         ImagePlacementDestination: {
             createsVolume: boolean;
             objectCount: number;
@@ -3128,13 +3142,15 @@ export interface components {
             canDelete: boolean;
             crossingRelationshipCount: number;
             imageId: string;
-            partitionIndex: number;
             revision: number;
-            volumeName: string;
+            targets: components['schemas']['ImageVolumeDeletionTarget'][];
         };
         ImageVolumeDeletionInspectionRequest: {
             expectedRevision: number;
             imageId: string;
+            targets: components['schemas']['ImageVolumeDeletionTarget'][];
+        };
+        ImageVolumeDeletionTarget: {
             partitionIndex: number;
             volumeName: string;
         };
diff --git a/apps/axkdeck/src/lib/httpImageSessions.ts b/apps/axkdeck/src/lib/httpImageSessions.ts
index 004b95f2..c3320115 100644
--- a/apps/axkdeck/src/lib/httpImageSessions.ts
+++ b/apps/axkdeck/src/lib/httpImageSessions.ts
@@ -240,15 +240,13 @@ export class HttpImageSessions {
 
     async inspectVolumeDeletion(
         sessionId: number,
-        partitionIndex: number,
-        volumeName: string,
+        targets: components['schemas']['ImageVolumeDeletionTarget'][],
     ): Promise<VolumeDeletionInspection> {
         const session = this.get(sessionId);
         const result = await this.client.invoke<VolumeDeletionInspection>('images.volume_deletion.inspect', {
             imageId: session.remoteId,
             expectedRevision: session.revision,
-            partitionIndex,
-            volumeName,
+            targets,
         });
         if (this.jobs.isJob(result)) throw new Error('images.volume_deletion.inspect unexpectedly returned a job');
         return result;
@@ -293,6 +291,7 @@ export class HttpImageSessions {
     async inspectObjectDeletion(
         sessionId: number,
         targetObjectIds: string[],
+        referrerObjectIds: string[],
         cleanupObjectIds: string[],
     ): Promise<ObjectDeletionInspection> {
         const session = this.get(sessionId);
@@ -300,6 +299,7 @@ export class HttpImageSessions {
             imageId: session.remoteId,
             expectedRevision: session.revision,
             targetObjectIds,
+            referrerObjectIds,
             cleanupObjectIds,
         });
         if (this.jobs.isJob(result)) throw new Error('images.deletion.inspect unexpectedly returned a job');
@@ -320,6 +320,7 @@ export class HttpImageSessions {
     async startObjectDeletion(
         sessionId: number,
         targetObjectIds: string[],
+        referrerObjectIds: string[],
         cleanupObjectIds: string[],
     ): Promise<JobState> {
         const session = this.get(sessionId);
@@ -329,6 +330,7 @@ export class HttpImageSessions {
                 imageId: session.remoteId,
                 expectedRevision: session.revision,
                 targetObjectIds,
+                referrerObjectIds,
                 cleanupObjectIds,
             },
             { idempotencyKey: randomIdempotencyKey() },
@@ -388,7 +390,8 @@ export class HttpImageSessions {
         return this.jobs.map(result);
     }
 
-    async startMutation(sessionId: number, operation: Record<string, unknown>): Promise<JobState> {
+    async startMutations(sessionId: number, operations: Record<string, unknown>[]): Promise<JobState> {
+        if (operations.length === 0) throw new Error('at least one image mutation is required');
         const session = this.get(sessionId);
         const job = await this.client.invoke<never>(
             'images.alter',
@@ -398,7 +401,7 @@ export class HttpImageSessions {
                 manifest: {
                     inline: {
                         schema_version: ALTERATION_MANIFEST_SCHEMA_VERSION,
-                        operations: [operation],
+                        operations,
                     },
                 },
                 inputBindings: [],
diff --git a/apps/axkdeck/src/lib/httpTransport.test.ts b/apps/axkdeck/src/lib/httpTransport.test.ts
index 20717600..b134e583 100644
--- a/apps/axkdeck/src/lib/httpTransport.test.ts
+++ b/apps/axkdeck/src/lib/httpTransport.test.ts
@@ -172,6 +172,11 @@ describe('HttpImageTransport', () => {
                                 name: 'PARTITION 1',
                                 displayName: 'partition 0: PARTITION 1',
                                 partitionIndex: 0,
+                                partitionCapacity: {
+                                    allocatedClusters: 80,
+                                    freeClusters: 20,
+                                    clusterSizeBytes: 1024,
+                                },
                                 childCount: 1,
                                 scopeRole: 'CONTAINED',
                             },
@@ -193,6 +198,7 @@ describe('HttpImageTransport', () => {
                                 partitionIndex: 0,
                                 childCount: 0,
                                 scopeRole: 'CONTAINED',
+                                sizeBytes: 1_048_576,
                             },
                         ],
                         totalCount: 1,
@@ -213,6 +219,7 @@ describe('HttpImageTransport', () => {
                                 volumeName: 'Volume',
                                 categoryName: 'SMPL',
                                 sizeBytes: 88_064,
+                                sizeWithDependenciesBytes: null,
                                 waveform: {
                                     sampleRate: 44100,
                                     sampleWidthBytes: 2,
@@ -266,12 +273,18 @@ describe('HttpImageTransport', () => {
             childCount: 1,
             partitionIndex: 0,
             scopeRole: 'CONTAINED',
+            partitionCapacity: {
+                allocatedClusters: 80,
+                freeClusters: 20,
+                clusterSizeBytes: 1024,
+            },
         });
         expect(opened.tree[0]?.children?.[0]?.children?.[0]).toMatchObject({
             id: 'volume-1',
             name: 'drumloops',
             volumeName: 'drumloops',
             scopeRole: 'CONTAINED',
+            sizeBytes: 1_048_576,
         });
         expect(opened.objects).toEqual([]);
         await expect(
@@ -283,6 +296,7 @@ describe('HttpImageTransport', () => {
                     sampleRate: 44100,
                     rootKey: 60,
                     storedSizeBytes: 88_064,
+                    sizeWithDependenciesBytes: null,
                 },
             ],
             totalCount: 2,
@@ -1004,24 +1018,35 @@ describe('HttpImageTransport', () => {
         });
         const source = serverFile('images/base.hds');
         const opened = await transport.openImage(source);
-        await transport.startVolumeMutation(opened.sessionId, {
-            kind: 'add',
-            partitionIndex: 2,
-            volumeName: 'New Volume',
-        });
+        await transport.startVolumeMutations(opened.sessionId, [
+            {
+                kind: 'add',
+                partitionIndex: 2,
+                volumeName: 'New Volume',
+            },
+        ]);
         const refreshed = await transport.refreshImage(opened.sessionId);
         expect(refreshed.sessionId).toBe(opened.sessionId);
-        await transport.startVolumeMutation(opened.sessionId, {
-            kind: 'rename',
-            partitionIndex: 2,
-            volumeName: 'Old Volume',
-            newVolumeName: 'Renamed Volume',
-        });
-        await transport.startVolumeMutation(opened.sessionId, {
-            kind: 'delete',
-            partitionIndex: 2,
-            volumeName: 'Renamed Volume',
-        });
+        await transport.startVolumeMutations(opened.sessionId, [
+            {
+                kind: 'rename',
+                partitionIndex: 2,
+                volumeName: 'Old Volume',
+                newVolumeName: 'Renamed Volume',
+            },
+        ]);
+        await transport.startVolumeMutations(opened.sessionId, [
+            {
+                kind: 'delete',
+                partitionIndex: 2,
+                volumeName: 'Renamed Volume',
+            },
+            {
+                kind: 'delete',
+                partitionIndex: 4,
+                volumeName: 'Second Volume',
+            },
+        ]);
         await transport.startPartitionMutation(opened.sessionId, {
             kind: 'rename',
             partitionIndex: 2,
@@ -1103,11 +1128,17 @@ describe('HttpImageTransport', () => {
                         schema_version: '1.0',
                         operations: [
                             {
-                                id: 'volume-delete',
+                                id: 'volume-delete-1',
                                 type: 'delete_volume',
                                 partition_index: 2,
                                 volume_name: 'Renamed Volume',
                             },
+                            {
+                                id: 'volume-delete-2',
+                                type: 'delete_volume',
+                                partition_index: 4,
+                                volume_name: 'Second Volume',
+                            },
                         ],
                     },
                 },
@@ -1295,8 +1326,7 @@ describe('HttpImageTransport', () => {
                     return json({
                         imageId: 'image-repair',
                         revision: 4,
-                        partitionIndex: 0,
-                        volumeName: 'Samples',
+                        targets: [{ partitionIndex: 0, volumeName: 'Samples' }],
                         canDelete: false,
                         crossingRelationshipCount: 1,
                         blockers: [
@@ -1353,7 +1383,8 @@ describe('HttpImageTransport', () => {
             mode: 'remote',
         });
         const opened = await transport.openImage(serverFile('images/base.hds'));
-        const deletion = await transport.inspectVolumeDeletion(opened.sessionId, 0, 'Samples');
+        const deletionTargets = [{ partitionIndex: 0, volumeName: 'Samples' }];
+        const deletion = await transport.inspectVolumeDeletion(opened.sessionId, deletionTargets);
         expect(deletion).toMatchObject({ canDelete: false, crossingRelationshipCount: 1 });
         const scope = { kind: 'VOLUME' as const, partitionIndex: 0, volumeName: 'Samples' };
         const inspection = await transport.inspectPlacement(opened.sessionId, scope);
@@ -1363,8 +1394,7 @@ describe('HttpImageTransport', () => {
         expect(bodies.get('inspect')).toEqual({
             imageId: 'image-repair',
             expectedRevision: 4,
-            partitionIndex: 0,
-            volumeName: 'Samples',
+            targets: deletionTargets,
         });
         expect(bodies.get('placementInspect')).toEqual({
             imageId: 'image-repair',
@@ -1451,6 +1481,7 @@ describe('HttpImageTransport', () => {
                                 volumeName: 'Volume',
                                 role: 'TARGET',
                                 status: 'REQUIRED',
+                                requested: true,
                                 selected: true,
                                 storedSizeBytes: 512,
                                 freedClusters: 1,
@@ -1466,6 +1497,7 @@ describe('HttpImageTransport', () => {
                                 volumeName: 'Volume',
                                 role: 'DEPENDENCY',
                                 status: 'OPTIONAL',
+                                requested: true,
                                 selected: true,
                                 storedSizeBytes: 4096,
                                 freedClusters: 4,
@@ -1507,19 +1539,25 @@ describe('HttpImageTransport', () => {
         const opened = await transport.openImage(serverFile('images/base.hds'));
         expect(opened.objectDeletionAvailable).toBe(true);
 
-        const inspection = await transport.inspectObjectDeletion(opened.sessionId, ['object-sample'], ['object-wave']);
+        const inspection = await transport.inspectObjectDeletion(
+            opened.sessionId,
+            ['object-sample'],
+            [],
+            ['object-wave'],
+        );
         expect(inspection).toMatchObject({
             canApply: true,
             selectedObjectIds: ['object-sample', 'object-wave'],
             estimatedFreedClusters: 5,
         });
-        const job = await transport.startObjectDeletion(opened.sessionId, ['object-sample'], ['object-wave']);
+        const job = await transport.startObjectDeletion(opened.sessionId, ['object-sample'], [], ['object-wave']);
         expect(job).toMatchObject({ kind: 'images.delete', status: 'queued' });
 
         const expected = {
             imageId: 'image-delete',
             expectedRevision: 7,
             targetObjectIds: ['object-sample'],
+            referrerObjectIds: [],
             cleanupObjectIds: ['object-wave'],
         };
         expect(bodies.get('inspect')).toEqual(expected);
diff --git a/apps/axkdeck/src/lib/httpTransport.ts b/apps/axkdeck/src/lib/httpTransport.ts
index cf3c44d9..3d013580 100644
--- a/apps/axkdeck/src/lib/httpTransport.ts
+++ b/apps/axkdeck/src/lib/httpTransport.ts
@@ -58,8 +58,9 @@ import type {
     MidiInspection,
     Tx16wImportInspection,
     Tx16wImportMode,
-    VolumeMutation,
     VolumeDeletionInspection,
+    VolumeDeletionTarget,
+    VolumeMutation,
     ConnectionMode,
 } from './transport';
 import {
@@ -350,30 +351,33 @@ export class HttpImageTransport extends HttpImageSessionReads implements ImageTr
     deleteRetainedPackage(download: components['schemas']['RetainedDownload']): Promise<void> {
         return this.packages.deleteRetained(download);
     }
-    async startVolumeMutation(sessionId: number, mutation: VolumeMutation): Promise<JobState> {
-        return this.imageSessions.startMutation(sessionId, volumeMutationOperation(mutation));
+    async startVolumeMutations(sessionId: number, mutations: VolumeMutation[]): Promise<JobState> {
+        return this.imageSessions.startMutations(
+            sessionId,
+            mutations.map((mutation, index) =>
+                volumeMutationOperation(mutation, mutations.length === 1 ? undefined : index + 1),
+            ),
+        );
     }
 
     async startPartitionMutation(sessionId: number, mutation: PartitionMutation): Promise<JobState> {
-        return this.imageSessions.startMutation(sessionId, {
-            id: 'partition-rename',
-            type: 'rename_partition',
-            partition_index: mutation.partitionIndex,
-            partition_name: mutation.partitionName,
-            new_partition_name: mutation.newPartitionName,
-        });
+        return this.imageSessions.startMutations(sessionId, [
+            {
+                id: 'partition-rename',
+                type: 'rename_partition',
+                partition_index: mutation.partitionIndex,
+                partition_name: mutation.partitionName,
+                new_partition_name: mutation.newPartitionName,
+            },
+        ]);
     }
 
     async startObjectRename(sessionId: number, mutation: ObjectRenameMutation): Promise<JobState> {
-        return this.imageSessions.startMutation(sessionId, objectRenameOperation(mutation));
+        return this.imageSessions.startMutations(sessionId, [objectRenameOperation(mutation)]);
     }
 
-    inspectVolumeDeletion(
-        sessionId: number,
-        partitionIndex: number,
-        volumeName: string,
-    ): Promise<VolumeDeletionInspection> {
-        return this.imageSessions.inspectVolumeDeletion(sessionId, partitionIndex, volumeName);
+    inspectVolumeDeletion(sessionId: number, targets: VolumeDeletionTarget[]): Promise<VolumeDeletionInspection> {
+        return this.imageSessions.inspectVolumeDeletion(sessionId, targets);
     }
 
     inspectPlacement(
@@ -395,17 +399,28 @@ export class HttpImageTransport extends HttpImageSessionReads implements ImageTr
     inspectObjectDeletion(
         sessionId: number,
         targetObjectIds: string[],
+        referrerObjectIds: string[],
         cleanupObjectIds: string[],
     ): Promise<ObjectDeletionInspection> {
-        return this.imageSessions.inspectObjectDeletion(sessionId, targetObjectIds, cleanupObjectIds);
+        return this.imageSessions.inspectObjectDeletion(
+            sessionId,
+            targetObjectIds,
+            referrerObjectIds,
+            cleanupObjectIds,
+        );
     }
 
     inspectWaveDataOrphans(sessionId: number, contentScopeId: string): Promise<WaveDataOrphanInspection> {
         return this.imageSessions.inspectWaveDataOrphans(sessionId, contentScopeId);
     }
 
-    startObjectDeletion(sessionId: number, targetObjectIds: string[], cleanupObjectIds: string[]): Promise<JobState> {
-        return this.imageSessions.startObjectDeletion(sessionId, targetObjectIds, cleanupObjectIds);
+    startObjectDeletion(
+        sessionId: number,
+        targetObjectIds: string[],
+        referrerObjectIds: string[],
+        cleanupObjectIds: string[],
+    ): Promise<JobState> {
+        return this.imageSessions.startObjectDeletion(sessionId, targetObjectIds, referrerObjectIds, cleanupObjectIds);
     }
 
     inspectProgramGeneration(sessionId: number, contentScopeId: string): Promise<ProgramGenerationInspection> {
diff --git a/apps/axkdeck/src/lib/httpTransportModels.ts b/apps/axkdeck/src/lib/httpTransportModels.ts
index c3ccd9e1..9762b558 100644
--- a/apps/axkdeck/src/lib/httpTransportModels.ts
+++ b/apps/axkdeck/src/lib/httpTransportModels.ts
@@ -81,6 +81,8 @@ export function mapContentItem(item: ApiContentItem, parent?: DiskTreeItem): Dis
         volumeDirectoryId: item.volumeDirectoryId ?? undefined,
         volumeName,
         partitionIndex,
+        partitionCapacity: item.partitionCapacity ?? undefined,
+        sizeBytes: item.sizeBytes ?? undefined,
     };
 }
 
@@ -95,6 +97,7 @@ export function mapObject(item: ApiObjectItem): SamplerObject {
         categoryName: item.categoryName,
         sfsId: 0,
         storedSizeBytes: item.sizeBytes,
+        sizeWithDependenciesBytes: item.sizeWithDependenciesBytes,
         sampleRate: item.waveform?.sampleRate ?? 0,
         rootKey: item.waveform?.rootKey ?? 0,
         frameCount: item.waveform?.frameCount ?? 0,
diff --git a/apps/axkdeck/src/lib/httpTransportWire.ts b/apps/axkdeck/src/lib/httpTransportWire.ts
index d8648689..827fd0e7 100644
--- a/apps/axkdeck/src/lib/httpTransportWire.ts
+++ b/apps/axkdeck/src/lib/httpTransportWire.ts
@@ -59,9 +59,9 @@ export function createPlanKey(
     ]);
 }
 
-export function volumeMutationOperation(mutation: VolumeMutation): Record<string, unknown> {
+export function volumeMutationOperation(mutation: VolumeMutation, operationNumber?: number): Record<string, unknown> {
     const common = {
-        id: `volume-${mutation.kind}`,
+        id: `volume-${mutation.kind}${operationNumber === undefined ? '' : `-${operationNumber}`}`,
         partition_index: mutation.partitionIndex,
     };
     if (mutation.kind === 'add') {
diff --git a/apps/axkdeck/src/lib/interfaceScale.test.ts b/apps/axkdeck/src/lib/interfaceScale.test.ts
index 13db8f0b..354e36bc 100644
--- a/apps/axkdeck/src/lib/interfaceScale.test.ts
+++ b/apps/axkdeck/src/lib/interfaceScale.test.ts
@@ -72,25 +72,6 @@ function adapterFor(initialMonitor: InterfaceScaleMonitor | null = monitor(1920,
     };
 }
 
-function storageWith(value?: string): Storage {
-    const values = new Map<string, string>();
-    if (value !== undefined) values.set('axkdeck.interface-scale.v1', value);
-    return {
-        get length() {
-            return values.size;
-        },
-        clear: () => values.clear(),
-        getItem: (key) => values.get(key) ?? null,
-        key: (index) => [...values.keys()][index] ?? null,
-        removeItem: (key) => {
-            values.delete(key);
-        },
-        setItem: (key, next) => {
-            values.set(key, next);
-        },
-    };
-}
-
 describe('automaticInterfaceZoom', () => {
     it.each([
         [monitor(1920, 1080), 1],
@@ -124,7 +105,7 @@ describe('InterfaceScaleController', () => {
     it('applies automatic scaling and scaled minimum window constraints before returning', async () => {
         const { adapter } = adapterFor(monitor(3840, 2160));
 
-        const controller = await createInterfaceScaleController(adapter, storageWith());
+        const controller = await createInterfaceScaleController(adapter, 'auto');
 
         expect(controller.state()).toEqual({ mode: 'auto', appliedZoom: 1.5 });
         expect(adapter.setMinSize).toHaveBeenCalledWith(1200, 900);
@@ -136,7 +117,7 @@ describe('InterfaceScaleController', () => {
     it('applies native window constraints on startup at neutral zoom', async () => {
         const { adapter } = adapterFor(monitor(1920, 1080));
 
-        const controller = await createInterfaceScaleController(adapter, storageWith());
+        const controller = await createInterfaceScaleController(adapter, 'auto');
 
         expect(adapter.setMinSize).toHaveBeenCalledWith(800, 600);
         expect(adapter.setSize).not.toHaveBeenCalled();
@@ -148,7 +129,7 @@ describe('InterfaceScaleController', () => {
         const { adapter } = adapterFor(monitor(3840, 2160));
         vi.mocked(adapter.innerSize).mockResolvedValue({ width: 1000, height: 700 });
 
-        const controller = await createInterfaceScaleController(adapter, storageWith());
+        const controller = await createInterfaceScaleController(adapter, 'auto');
 
         expect(adapter.setSize).toHaveBeenCalledWith(1200, 900);
         expect(vi.mocked(adapter.setSize).mock.invocationCallOrder[0]).toBeLessThan(
@@ -159,8 +140,8 @@ describe('InterfaceScaleController', () => {
 
     it('loads fixed persisted modes and ignores monitor changes until Auto is selected', async () => {
         const { adapter, emitScaleChanged, setMonitor } = adapterFor(monitor(1920, 1080));
-        const storage = storageWith('1.25');
-        const controller = await createInterfaceScaleController(adapter, storage);
+        const persistMode = vi.fn(async () => undefined);
+        const controller = await createInterfaceScaleController(adapter, '1.25', persistMode);
 
         expect(controller.state()).toEqual({ mode: '1.25', appliedZoom: 1.25 });
         setMonitor(monitor(3840, 2160));
@@ -169,56 +150,33 @@ describe('InterfaceScaleController', () => {
         expect(controller.state()).toEqual({ mode: '1.25', appliedZoom: 1.25 });
 
         await controller.setMode('auto');
-        expect(storage.getItem('axkdeck.interface-scale.v1')).toBe('auto');
+        expect(persistMode).toHaveBeenCalledWith('auto');
         expect(controller.state()).toEqual({ mode: 'auto', appliedZoom: 1.5 });
         await controller.dispose();
     });
 
     it('restores and applies the fixed 115% mode', async () => {
         const { adapter } = adapterFor(monitor(1920, 1080));
-        const controller = await createInterfaceScaleController(adapter, storageWith('1.15'));
+        const controller = await createInterfaceScaleController(adapter, '1.15');
 
         expect(controller.state()).toEqual({ mode: '1.15', appliedZoom: 1.15 });
         expect(adapter.setZoom).toHaveBeenCalledWith(1.15);
         await controller.dispose();
     });
 
-    it.each(['', '125%', '2', 'invalid'])('falls back to Auto for an invalid stored mode %j', async (stored) => {
-        const { adapter } = adapterFor(monitor(2560, 1440));
-
-        const controller = await createInterfaceScaleController(adapter, storageWith(stored));
-
-        expect(controller.state()).toEqual({ mode: 'auto', appliedZoom: 1.25 });
-        await controller.dispose();
-    });
-
-    it('continues when scale preferences cannot be read or written', async () => {
+    it('continues when a scale preference cannot be persisted', async () => {
         const { adapter } = adapterFor(monitor(3840, 2160));
         const report = vi.fn();
-        const storage = {
-            getItem: vi.fn(() => {
-                throw new Error('read failed');
-            }),
-            setItem: vi.fn(() => {
-                throw new Error('write failed');
-            }),
-            removeItem: vi.fn(),
-            clear: vi.fn(),
-            key: vi.fn(),
-            length: 0,
-        } satisfies Storage;
-
-        const controller = await createInterfaceScaleController(adapter, storage, report);
+        const persistMode = vi.fn(async () => {
+            throw new Error('write failed');
+        });
+
+        const controller = await createInterfaceScaleController(adapter, 'auto', persistMode, report);
         await controller.setMode('1.25');
 
         expect(controller.state()).toEqual({ mode: '1.25', appliedZoom: 1.25 });
         expect(report).toHaveBeenCalledWith(
-            'interface_scale_storage_failed',
-            expect.objectContaining({ message: 'read failed' }),
-            'warn',
-        );
-        expect(report).toHaveBeenCalledWith(
-            'interface_scale_storage_failed',
+            'interface_scale_persistence_failed',
             expect.objectContaining({ message: 'write failed' }),
             'warn',
         );
@@ -227,7 +185,7 @@ describe('InterfaceScaleController', () => {
 
     it('debounces window movement, reacts immediately to scale changes, and suppresses duplicate mutations', async () => {
         const { adapter, emitMoved, emitScaleChanged, setMonitor } = adapterFor(monitor(1920, 1080));
-        const controller = await createInterfaceScaleController(adapter, storageWith());
+        const controller = await createInterfaceScaleController(adapter, 'auto');
         vi.mocked(adapter.setMinSize).mockClear();
         vi.mocked(adapter.setSize).mockClear();
         vi.mocked(adapter.setZoom).mockClear();
@@ -254,10 +212,7 @@ describe('InterfaceScaleController', () => {
         'does not mutate the native window when maximizing in %s mode',
         async (mode) => {
             const { adapter, emitMoved, emitResized, setMaximized } = adapterFor(monitor(1920, 1080));
-            const controller = await createInterfaceScaleController(
-                adapter,
-                storageWith(mode === 'auto' ? undefined : mode),
-            );
+            const controller = await createInterfaceScaleController(adapter, mode);
             vi.mocked(adapter.setMinSize).mockClear();
             vi.mocked(adapter.setSize).mockClear();
             vi.mocked(adapter.setZoom).mockClear();
@@ -278,7 +233,7 @@ describe('InterfaceScaleController', () => {
         'defers changed native constraints while %s and reconciles them once after restore',
         async (windowState) => {
             const { adapter, emitResized, setFullscreen, setMaximized } = adapterFor(monitor(1920, 1080));
-            const controller = await createInterfaceScaleController(adapter, storageWith());
+            const controller = await createInterfaceScaleController(adapter, 'auto');
             vi.mocked(adapter.setMinSize).mockClear();
             vi.mocked(adapter.setSize).mockClear();
             vi.mocked(adapter.setZoom).mockClear();
@@ -313,14 +268,14 @@ describe('InterfaceScaleController', () => {
 
     it('notifies subscribers, persists valid modes, and removes listeners on disposal', async () => {
         const { adapter, emitMoved, emitResized, emitScaleChanged } = adapterFor(monitor(1920, 1080));
-        const storage = storageWith();
-        const controller = await createInterfaceScaleController(adapter, storage);
+        const persistMode = vi.fn(async () => undefined);
+        const controller = await createInterfaceScaleController(adapter, 'auto', persistMode);
         const listener = vi.fn();
         const unsubscribe = controller.subscribe(listener);
 
         await controller.setMode('1.5');
 
-        expect(storage.getItem('axkdeck.interface-scale.v1')).toBe('1.5');
+        expect(persistMode).toHaveBeenCalledWith('1.5');
         expect(listener).toHaveBeenLastCalledWith({ mode: '1.5', appliedZoom: 1.5 });
         unsubscribe();
         await controller.dispose();
@@ -336,7 +291,7 @@ describe('InterfaceScaleController', () => {
         vi.mocked(adapter.setZoom).mockRejectedValue(new Error('zoom unavailable'));
         const report = vi.fn();
 
-        const controller = await createInterfaceScaleController(adapter, storageWith(), report);
+        const controller = await createInterfaceScaleController(adapter, 'auto', undefined, report);
 
         expect(controller.state()).toEqual({ mode: 'auto', appliedZoom: 1 });
         expect(report).toHaveBeenCalledWith(
@@ -349,7 +304,7 @@ describe('InterfaceScaleController', () => {
 
     it('accepts every declared fixed mode', async () => {
         const { adapter } = adapterFor();
-        const controller = await createInterfaceScaleController(adapter, storageWith());
+        const controller = await createInterfaceScaleController(adapter, 'auto');
         const modes: InterfaceScaleMode[] = ['1', '1.15', '1.25', '1.5', 'auto'];
 
         for (const mode of modes) await controller.setMode(mode);
diff --git a/apps/axkdeck/src/lib/interfaceScale.ts b/apps/axkdeck/src/lib/interfaceScale.ts
index bb509817..6358d96e 100644
--- a/apps/axkdeck/src/lib/interfaceScale.ts
+++ b/apps/axkdeck/src/lib/interfaceScale.ts
@@ -23,6 +23,7 @@ type ScaleReporter = (
     fields: Readonly<Record<string, unknown>>,
     level?: 'info' | 'warn' | 'error',
 ) => void;
+type PersistScaleMode = (mode: InterfaceScaleMode) => Promise<void>;
 
 export interface InterfaceScaleAdapter {
     currentMonitor(): Promise<InterfaceScaleMonitor | null>;
@@ -45,11 +46,9 @@ export interface InterfaceScaleController {
     dispose(): Promise<void>;
 }
 
-const storageKey = 'axkdeck.interface-scale.v1';
 const minimumWindowWidth = 800;
 const minimumWindowHeight = 600;
 const windowEventDebounceMs = 150;
-const fixedModes = new Set<InterfaceScaleMode>(['1', '1.15', '1.25', '1.5']);
 
 function finitePositive(value: number): boolean {
     return Number.isFinite(value) && value > 0;
@@ -78,10 +77,6 @@ export function automaticInterfaceZoom(monitor: InterfaceScaleMonitor | null): n
     return roundedZoom(Math.max(1, Math.min(1.5, target / monitor.scaleFactor)));
 }
 
-function validMode(value: string | null): value is InterfaceScaleMode {
-    return value === 'auto' || fixedModes.has(value as InterfaceScaleMode);
-}
-
 function fixedZoom(mode: InterfaceScaleMode): number | null {
     if (mode === 'auto') return null;
     return Number(mode);
@@ -93,17 +88,12 @@ function errorMessage(error: unknown): string {
 
 export async function createInterfaceScaleController(
     adapter: InterfaceScaleAdapter,
-    storage: Storage,
+    initialMode: InterfaceScaleMode,
+    persistMode: PersistScaleMode = async () => undefined,
     report: ScaleReporter = () => undefined,
 ): Promise<InterfaceScaleController> {
-    let stored: string | null = null;
-    try {
-        stored = storage.getItem(storageKey);
-    } catch (error) {
-        report('interface_scale_storage_failed', { message: errorMessage(error) }, 'warn');
-    }
     let current: InterfaceScaleState = {
-        mode: validMode(stored) ? stored : 'auto',
+        mode: initialMode,
         appliedZoom: 1,
     };
     const listeners = new Set<(state: InterfaceScaleState) => void>();
@@ -228,9 +218,9 @@ export async function createInterfaceScaleController(
             if (disposed) return;
             current = { ...current, mode };
             try {
-                storage.setItem(storageKey, mode);
+                await persistMode(mode);
             } catch (error) {
-                report('interface_scale_storage_failed', { message: errorMessage(error) }, 'warn');
+                report('interface_scale_persistence_failed', { message: errorMessage(error) }, 'warn');
             }
             notify();
             await queueApply();
diff --git a/apps/axkdeck/src/lib/objectPresentation.test.ts b/apps/axkdeck/src/lib/objectPresentation.test.ts
index 7438718b..a1df5a1d 100644
--- a/apps/axkdeck/src/lib/objectPresentation.test.ts
+++ b/apps/axkdeck/src/lib/objectPresentation.test.ts
@@ -13,6 +13,7 @@ function object(objectType: string, name: string): SamplerObject {
         categoryName: objectType,
         sfsId: 0,
         storedSizeBytes: 128,
+        sizeWithDependenciesBytes: null,
         sampleRate: 0,
         rootKey: 0,
         frameCount: 0,
diff --git a/apps/axkdeck/src/lib/objectSizePresentation.test.ts b/apps/axkdeck/src/lib/objectSizePresentation.test.ts
new file mode 100644
index 00000000..e55a1955
--- /dev/null
+++ b/apps/axkdeck/src/lib/objectSizePresentation.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { objectSizeSummary, objectSizeTooltip } from './objectSizePresentation';
+
+describe('object size presentation', () => {
+    it('distinguishes own bytes from an exact dependency closure', () => {
+        const object = { storedSizeBytes: 1024, sizeWithDependenciesBytes: 4096 };
+
+        expect(objectSizeSummary(object)).toBe('1 KiB · 4 KiB incl. deps.');
+        expect(objectSizeTooltip(object)).toBe('Object size: 1 KiB\nObject size with deps.: 4 KiB');
+    });
+
+    it('does not present an incomplete dependency graph as a lower bound', () => {
+        const object = { storedSizeBytes: 128, sizeWithDependenciesBytes: null };
+
+        expect(objectSizeSummary(object)).toBe('128 B · deps. unavailable');
+        expect(objectSizeTooltip(object)).toBe('Object size: 128 B\nObject size with deps.: Unavailable');
+    });
+});
diff --git a/apps/axkdeck/src/lib/objectSizePresentation.ts b/apps/axkdeck/src/lib/objectSizePresentation.ts
new file mode 100644
index 00000000..47195b72
--- /dev/null
+++ b/apps/axkdeck/src/lib/objectSizePresentation.ts
@@ -0,0 +1,21 @@
+import { formatStoredSize } from './formatBytes';
+
+interface SizedObject {
+    storedSizeBytes: number;
+    sizeWithDependenciesBytes: number | null;
+}
+
+export function objectSizeSummary(object: SizedObject): string {
+    const dependencySize = object.sizeWithDependenciesBytes;
+    return dependencySize === null
+        ? `${formatStoredSize(object.storedSizeBytes)} · deps. unavailable`
+        : `${formatStoredSize(object.storedSizeBytes)} · ${formatStoredSize(dependencySize)} incl. deps.`;
+}
+
+export function objectSizeTooltip(object: SizedObject): string {
+    const dependencySize = object.sizeWithDependenciesBytes;
+    return [
+        `Object size: ${formatStoredSize(object.storedSizeBytes)}`,
+        `Object size with deps.: ${dependencySize === null ? 'Unavailable' : formatStoredSize(dependencySize)}`,
+    ].join('\n');
+}
diff --git a/apps/axkdeck/src/lib/programSampleSelect.test.ts b/apps/axkdeck/src/lib/programSampleSelect.test.ts
index fac36ed7..fe9072c8 100644
--- a/apps/axkdeck/src/lib/programSampleSelect.test.ts
+++ b/apps/axkdeck/src/lib/programSampleSelect.test.ts
@@ -14,6 +14,7 @@ function object(objectType: string, name: string): SamplerObject {
         categoryName: objectType,
         sfsId: 0,
         storedSizeBytes: 128,
+        sizeWithDependenciesBytes: null,
         sampleRate: 44_100,
         rootKey: 60,
         frameCount: 44_100,
diff --git a/apps/axkdeck/src/lib/sampleRelationships.test.ts b/apps/axkdeck/src/lib/sampleRelationships.test.ts
index ab8a8eeb..742972a1 100644
--- a/apps/axkdeck/src/lib/sampleRelationships.test.ts
+++ b/apps/axkdeck/src/lib/sampleRelationships.test.ts
@@ -36,6 +36,7 @@ function waveData(id: string): WaveDataItem {
         categoryName: 'SMPL',
         sfsId: 0,
         storedSizeBytes: 2,
+        sizeWithDependenciesBytes: null,
         sampleRate: 44_100,
         rootKey: 60,
         frameCount: 1,
diff --git a/apps/axkdeck/src/lib/samplerTreeOrder.test.ts b/apps/axkdeck/src/lib/samplerTreeOrder.test.ts
new file mode 100644
index 00000000..add05e06
--- /dev/null
+++ b/apps/axkdeck/src/lib/samplerTreeOrder.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import type { DiskTreeItem } from './types';
+import { orderSamplerTreeItems } from './samplerTreeOrder';
+
+function item(id: string, name: string, kind: DiskTreeItem['kind'], partitionIndex?: number): DiskTreeItem {
+    return { id, name, kind, partitionIndex, childCount: 0 };
+}
+
+describe('sampler tree ordering', () => {
+    it('orders partitions by their sampler-visible ASCII names', () => {
+        const partitions = [
+            item('p0', '001_PARTITION 1', 'partition', 0),
+            item('p1', 'PARTITION 2', 'partition', 1),
+            item('p2', 'A_PARTITION 3', 'partition', 2),
+            item('p3', '_PARTITION 4', 'partition', 3),
+            item('p4', 'PARTITION 5', 'partition', 4),
+            item('p5', 'B_PARTITION 6', 'partition', 5),
+            item('p6', 'PARTITION 7', 'partition', 6),
+            item('p7', '$PARTITION 8', 'partition', 7),
+        ];
+
+        expect(orderSamplerTreeItems(partitions, 'partition').map(({ name }) => name)).toEqual([
+            '$PARTITION 8',
+            '001_PARTITION 1',
+            'A_PARTITION 3',
+            'B_PARTITION 6',
+            'PARTITION 2',
+            'PARTITION 5',
+            'PARTITION 7',
+            '_PARTITION 4',
+        ]);
+    });
+
+    it('orders volumes by their sampler-visible ASCII names without moving other node kinds', () => {
+        const volumes = [
+            item('v0', '$foo', 'volume'),
+            item('category', 'Programs', 'category'),
+            item('v1', 'a_foo', 'volume'),
+            item('v2', '001_foo', 'volume'),
+            item('v3', 'c_foo', 'volume'),
+            item('v4', '!foo', 'volume'),
+        ];
+
+        expect(orderSamplerTreeItems(volumes, 'volume').map(({ name }) => name)).toEqual([
+            '!foo',
+            'Programs',
+            '$foo',
+            '001_foo',
+            'a_foo',
+            'c_foo',
+        ]);
+    });
+
+    it('uses physical identity as the tie-breaker without mutating the source', () => {
+        const partitions = [item('p7', 'SAME', 'partition', 7), item('p0', 'SAME', 'partition', 0)];
+
+        expect(orderSamplerTreeItems(partitions, 'partition').map(({ id }) => id)).toEqual(['p0', 'p7']);
+        expect(partitions.map(({ id }) => id)).toEqual(['p7', 'p0']);
+    });
+});
diff --git a/apps/axkdeck/src/lib/samplerTreeOrder.ts b/apps/axkdeck/src/lib/samplerTreeOrder.ts
new file mode 100644
index 00000000..f03afe14
--- /dev/null
+++ b/apps/axkdeck/src/lib/samplerTreeOrder.ts
@@ -0,0 +1,37 @@
+import type { DiskTreeItem } from './types';
+
+type SamplerOrderedKind = Extract<DiskTreeItem['kind'], 'partition' | 'volume'>;
+
+function compareSamplerNames(left: string, right: string): number {
+    const sharedLength = Math.min(left.length, right.length);
+    for (let index = 0; index < sharedLength; index += 1) {
+        const difference = left.charCodeAt(index) - right.charCodeAt(index);
+        if (difference !== 0) return difference;
+    }
+    return left.length - right.length;
+}
+
+function compareOptionalNumber(left: number | undefined, right: number | undefined): number {
+    if (left === right) return 0;
+    if (left === undefined) return 1;
+    if (right === undefined) return -1;
+    return left - right;
+}
+
+function comparePhysicalIdentity(left: DiskTreeItem, right: DiskTreeItem): number {
+    return (
+        compareOptionalNumber(left.partitionIndex, right.partitionIndex) ||
+        compareOptionalNumber(left.volumeDirectoryId, right.volumeDirectoryId) ||
+        compareSamplerNames(left.id, right.id)
+    );
+}
+
+function compareSamplerTreeItems(left: DiskTreeItem, right: DiskTreeItem): number {
+    return compareSamplerNames(left.name, right.name) || comparePhysicalIdentity(left, right);
+}
+
+export function orderSamplerTreeItems(items: readonly DiskTreeItem[], kind: SamplerOrderedKind): DiskTreeItem[] {
+    const ordered = items.filter((item) => item.kind === kind).sort(compareSamplerTreeItems);
+    let orderedIndex = 0;
+    return items.map((item) => (item.kind === kind ? ordered[orderedIndex++]! : item));
+}
diff --git a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
index 092f1ef7..c3375f20 100644
--- a/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
+++ b/apps/axkdeck/src/lib/testing/inMemoryTransport.ts
@@ -62,6 +62,7 @@ import type {
     Tx16wImportMode,
     VolumeMutation,
     VolumeDeletionInspection,
+    VolumeDeletionTarget,
     WaveDataOrphanInspection,
 } from '../transport';
 import type {
@@ -266,8 +267,8 @@ export class InMemoryImageTransport implements ImageTransport {
         this.options.onClose?.(sessionId);
     }
 
-    startVolumeMutation(sessionId: number, mutation: VolumeMutation): Promise<JobState> {
-        return this.invoke('startVolumeMutation', [sessionId, mutation]);
+    startVolumeMutations(sessionId: number, mutations: VolumeMutation[]): Promise<JobState> {
+        return this.invoke('startVolumeMutations', [sessionId, mutations]);
     }
 
     startPartitionMutation(sessionId: number, mutation: PartitionMutation): Promise<JobState> {
@@ -278,12 +279,8 @@ export class InMemoryImageTransport implements ImageTransport {
         return this.invoke('startObjectRename', [sessionId, mutation]);
     }
 
-    inspectVolumeDeletion(
-        sessionId: number,
-        partitionIndex: number,
-        volumeName: string,
-    ): Promise<VolumeDeletionInspection> {
-        return this.invoke('inspectVolumeDeletion', [sessionId, partitionIndex, volumeName]);
+    inspectVolumeDeletion(sessionId: number, targets: VolumeDeletionTarget[]): Promise<VolumeDeletionInspection> {
+        return this.invoke('inspectVolumeDeletion', [sessionId, targets]);
     }
 
     inspectPlacement(
@@ -305,17 +302,23 @@ export class InMemoryImageTransport implements ImageTransport {
     inspectObjectDeletion(
         sessionId: number,
         targetObjectIds: string[],
+        referrerObjectIds: string[],
         cleanupObjectIds: string[],
     ): Promise<ObjectDeletionInspection> {
-        return this.invoke('inspectObjectDeletion', [sessionId, targetObjectIds, cleanupObjectIds]);
+        return this.invoke('inspectObjectDeletion', [sessionId, targetObjectIds, referrerObjectIds, cleanupObjectIds]);
     }
 
     inspectWaveDataOrphans(sessionId: number, contentScopeId: string): Promise<WaveDataOrphanInspection> {
         return this.invoke('inspectWaveDataOrphans', [sessionId, contentScopeId]);
     }
 
-    startObjectDeletion(sessionId: number, targetObjectIds: string[], cleanupObjectIds: string[]): Promise<JobState> {
-        return this.invoke('startObjectDeletion', [sessionId, targetObjectIds, cleanupObjectIds]);
+    startObjectDeletion(
+        sessionId: number,
+        targetObjectIds: string[],
+        referrerObjectIds: string[],
+        cleanupObjectIds: string[],
+    ): Promise<JobState> {
+        return this.invoke('startObjectDeletion', [sessionId, targetObjectIds, referrerObjectIds, cleanupObjectIds]);
     }
 
     inspectProgramGeneration(sessionId: number, contentScopeId: string): Promise<ProgramGenerationInspection> {
diff --git a/apps/axkdeck/src/lib/transport.ts b/apps/axkdeck/src/lib/transport.ts
index bd2db196..e99db943 100644
--- a/apps/axkdeck/src/lib/transport.ts
+++ b/apps/axkdeck/src/lib/transport.ts
@@ -128,8 +128,9 @@ export interface ObjectDeletionImpact {
     partitionIndex: number | null;
     partitionName: string;
     volumeName: string;
-    role: 'TARGET' | 'DEPENDENCY';
+    role: 'TARGET' | 'REFERRER' | 'DEPENDENCY';
     status: 'REQUIRED' | 'OPTIONAL' | 'PRESERVED' | 'BLOCKED';
+    requested: boolean;
     selected: boolean;
     storedSizeBytes: number;
     freedClusters: number;
@@ -154,6 +155,8 @@ export interface ObjectDeletionInspection {
     imageId: string;
     revision: number;
     targetObjectIds: string[];
+    referrerObjectIds: string[];
+    cleanupObjectIds: string[];
     selectedObjectIds: string[];
     impacts: ObjectDeletionImpact[];
     references: ObjectDeletionReference[];
@@ -164,6 +167,7 @@ export interface ObjectDeletionInspection {
 }
 
 export type VolumeDeletionInspection = components['schemas']['ImageVolumeDeletionInspection'];
+export type VolumeDeletionTarget = components['schemas']['ImageVolumeDeletionTarget'];
 export type ProgramGenerationCandidate = components['schemas']['ImageProgramGenerationCandidate'];
 export type ProgramGenerationInspection = components['schemas']['ImageProgramGenerationInspection'];
 export type ProgramGenerationSelection = components['schemas']['ImageProgramGenerationSelection'];
@@ -238,6 +242,7 @@ export interface SamplerObject {
     categoryName: string;
     sfsId: number;
     storedSizeBytes: number;
+    sizeWithDependenciesBytes: number | null;
     sampleRate: number;
     rootKey: number;
     frameCount: number;
@@ -490,14 +495,10 @@ export interface ImageTransport {
     systemProgramContexts(sessionId: number, partitionIndex: number): Promise<SystemProgramContexts>;
     allocationMapReference(sessionId: number): Promise<AllocationMapReference>;
     closeImage(sessionId: number): Promise<void>;
-    startVolumeMutation(sessionId: number, mutation: VolumeMutation): Promise<JobState>;
+    startVolumeMutations(sessionId: number, mutations: VolumeMutation[]): Promise<JobState>;
     startPartitionMutation(sessionId: number, mutation: PartitionMutation): Promise<JobState>;
     startObjectRename(sessionId: number, mutation: ObjectRenameMutation): Promise<JobState>;
-    inspectVolumeDeletion(
-        sessionId: number,
-        partitionIndex: number,
-        volumeName: string,
-    ): Promise<VolumeDeletionInspection>;
+    inspectVolumeDeletion(sessionId: number, targets: VolumeDeletionTarget[]): Promise<VolumeDeletionInspection>;
     inspectPlacement(
         sessionId: number,
         scope: PlacementRepairScope,
@@ -511,10 +512,16 @@ export interface ImageTransport {
     inspectObjectDeletion(
         sessionId: number,
         targetObjectIds: string[],
+        referrerObjectIds: string[],
         cleanupObjectIds: string[],
     ): Promise<ObjectDeletionInspection>;
     inspectWaveDataOrphans(sessionId: number, contentScopeId: string): Promise<WaveDataOrphanInspection>;
-    startObjectDeletion(sessionId: number, targetObjectIds: string[], cleanupObjectIds: string[]): Promise<JobState>;
+    startObjectDeletion(
+        sessionId: number,
+        targetObjectIds: string[],
+        referrerObjectIds: string[],
+        cleanupObjectIds: string[],
+    ): Promise<JobState>;
     inspectProgramGeneration(sessionId: number, contentScopeId: string): Promise<ProgramGenerationInspection>;
     startProgramGeneration(
         sessionId: number,
diff --git a/apps/axkdeck/src/lib/transportConformance.test.ts b/apps/axkdeck/src/lib/transportConformance.test.ts
index a427a4c5..4545acb5 100644
--- a/apps/axkdeck/src/lib/transportConformance.test.ts
+++ b/apps/axkdeck/src/lib/transportConformance.test.ts
@@ -16,6 +16,7 @@ const object: SamplerObject = {
     categoryName: 'SMPL',
     sfsId: 9,
     storedSizeBytes: 128,
+    sizeWithDependenciesBytes: null,
     sampleRate: 44_100,
     rootKey: 60,
     frameCount: 4,
diff --git a/apps/axkdeck/src/lib/types.ts b/apps/axkdeck/src/lib/types.ts
index ba49932e..ba45d26c 100644
--- a/apps/axkdeck/src/lib/types.ts
+++ b/apps/axkdeck/src/lib/types.ts
@@ -24,6 +24,12 @@ export interface PackageExportVolume {
 
 export type PackageExportSelection = PackageExportObject | PackageExportVolume;
 
+export interface PartitionCapacity {
+    allocatedClusters: number;
+    freeClusters: number;
+    clusterSizeBytes: number;
+}
+
 export interface DiskTreeItem {
     id: string;
     name: string;
@@ -37,6 +43,8 @@ export interface DiskTreeItem {
     volumeDirectoryId?: number;
     volumeName?: string;
     partitionIndex?: number;
+    partitionCapacity?: PartitionCapacity;
+    sizeBytes?: number;
 }
 
 export type ImageTreeAction =
@@ -46,7 +54,6 @@ export type ImageTreeAction =
     | 'rename-partition'
     | 'inspect-allocation'
     | 'repair-placement'
-    | 'import-package'
     | 'import-packages'
     | 'export-package'
     | 'export-volume-packages'
diff --git a/apps/axkdeck/src/lib/volumeSelection.test.ts b/apps/axkdeck/src/lib/volumeSelection.test.ts
new file mode 100644
index 00000000..95e8099c
--- /dev/null
+++ b/apps/axkdeck/src/lib/volumeSelection.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import type { DiskTreeItem } from './types';
+import { emptyVolumeSelection, updateVolumeSelection } from './volumeSelection';
+
+const volume = (id: string, partitionIndex: number): DiskTreeItem => ({
+    id,
+    name: id,
+    kind: 'volume',
+    childCount: 0,
+    partitionIndex,
+});
+
+const partition = (id: string, partitionIndex: number): DiskTreeItem => ({
+    id,
+    name: id,
+    kind: 'partition',
+    childCount: 0,
+    partitionIndex,
+});
+
+describe('volume selection', () => {
+    const visible = [volume('a', 0), volume('b', 0), volume('c', 1), volume('d', 1)];
+
+    it('supports toggle and cross-partition visible ranges', () => {
+        let selection = updateVolumeSelection(emptyVolumeSelection(), visible, visible[0]!, 'replace').selection;
+        selection = updateVolumeSelection(selection, visible, visible[2]!, 'add-range').selection;
+        expect(selection.items.map((item) => item.id)).toEqual(['a', 'b', 'c']);
+
+        selection = updateVolumeSelection(selection, visible, visible[1]!, 'toggle').selection;
+        expect(selection.items.map((item) => item.id)).toEqual(['a', 'c']);
+    });
+
+    it('replaces the selected set for a plain click and range selection', () => {
+        let selection = updateVolumeSelection(emptyVolumeSelection(), visible, visible[0]!, 'replace').selection;
+        selection = updateVolumeSelection(selection, visible, visible[3]!, 'toggle').selection;
+        selection = updateVolumeSelection(selection, visible, visible[1]!, 'replace').selection;
+        expect(selection.items.map((item) => item.id)).toEqual(['b']);
+
+        selection = updateVolumeSelection(selection, visible, visible[3]!, 'range').selection;
+        expect(selection.items.map((item) => item.id)).toEqual(['b', 'c', 'd']);
+    });
+
+    it('moves the active item to the nearest remaining volume when toggled off', () => {
+        let selection = updateVolumeSelection(emptyVolumeSelection(), visible, visible[0]!, 'replace').selection;
+        selection = updateVolumeSelection(selection, visible, visible[1]!, 'toggle').selection;
+        selection = updateVolumeSelection(selection, visible, visible[2]!, 'toggle').selection;
+
+        const update = updateVolumeSelection(selection, visible, visible[1]!, 'toggle');
+        expect(update.selection.items.map((item) => item.id)).toEqual(['a', 'c']);
+        expect(update.active.id).toBe('c');
+    });
+
+    it('clears volume selection when a non-volume row is selected', () => {
+        const selected = updateVolumeSelection(emptyVolumeSelection(), visible, visible[0]!, 'replace').selection;
+        const update = updateVolumeSelection(selected, visible, partition('partition', 0), 'replace');
+        expect(update.selection).toEqual(emptyVolumeSelection());
+        expect(update.active.id).toBe('partition');
+    });
+});
diff --git a/apps/axkdeck/src/lib/volumeSelection.ts b/apps/axkdeck/src/lib/volumeSelection.ts
new file mode 100644
index 00000000..2e67bf7f
--- /dev/null
+++ b/apps/axkdeck/src/lib/volumeSelection.ts
@@ -0,0 +1,73 @@
+import type { ObjectSelectionMode } from './objectSelection';
+import type { DiskTreeItem } from './types';
+
+export interface VolumeSelectionState {
+    items: DiskTreeItem[];
+    anchorId: string;
+}
+
+export interface VolumeSelectionUpdate {
+    selection: VolumeSelectionState;
+    active: DiskTreeItem;
+}
+
+export function emptyVolumeSelection(): VolumeSelectionState {
+    return { items: [], anchorId: '' };
+}
+
+export function updateVolumeSelection(
+    current: VolumeSelectionState,
+    visibleVolumes: readonly DiskTreeItem[],
+    target: DiskTreeItem,
+    mode: ObjectSelectionMode,
+): VolumeSelectionUpdate {
+    if (target.kind !== 'volume') return { selection: emptyVolumeSelection(), active: target };
+
+    const selected = new Map(current.items.map((item) => [item.id, item]));
+    let anchorId = target.id;
+    if (mode === 'replace') {
+        selected.clear();
+        selected.set(target.id, target);
+    } else if (mode === 'toggle') {
+        if (selected.has(target.id)) selected.delete(target.id);
+        else selected.set(target.id, target);
+    } else if (mode === 'range' || mode === 'add-range') {
+        const anchorIndex = visibleVolumes.findIndex((item) => item.id === current.anchorId);
+        const targetIndex = visibleVolumes.findIndex((item) => item.id === target.id);
+        const range =
+            anchorIndex < 0 || targetIndex < 0
+                ? [target]
+                : visibleVolumes.slice(Math.min(anchorIndex, targetIndex), Math.max(anchorIndex, targetIndex) + 1);
+        anchorId = anchorIndex < 0 ? target.id : current.anchorId;
+        if (mode === 'range') selected.clear();
+        for (const item of range) selected.set(item.id, item);
+    } else {
+        for (const item of visibleVolumes) selected.set(item.id, item);
+    }
+
+    const items = visibleVolumes.filter((item) => selected.has(item.id));
+    for (const item of selected.values()) {
+        if (!items.some((candidate) => candidate.id === item.id)) items.push(item);
+    }
+    const active = selected.has(target.id)
+        ? target
+        : (nearestSelectedVolume(visibleVolumes, target.id, selected) ?? target);
+    return { selection: { items, anchorId }, active };
+}
+
+function nearestSelectedVolume(
+    visibleVolumes: readonly DiskTreeItem[],
+    targetId: string,
+    selected: ReadonlyMap<string, DiskTreeItem>,
+): DiskTreeItem | null {
+    const targetIndex = visibleVolumes.findIndex((item) => item.id === targetId);
+    if (targetIndex >= 0) {
+        for (let distance = 1; distance < visibleVolumes.length; distance += 1) {
+            const after = visibleVolumes[targetIndex + distance];
+            if (after && selected.has(after.id)) return after;
+            const before = visibleVolumes[targetIndex - distance];
+            if (before && selected.has(before.id)) return before;
+        }
+    }
+    return selected.values().next().value ?? null;
+}
diff --git a/apps/axkdeck/src/main.ts b/apps/axkdeck/src/main.ts
index f8498544..cb69775e 100644
--- a/apps/axkdeck/src/main.ts
+++ b/apps/axkdeck/src/main.ts
@@ -3,7 +3,11 @@ import { invoke } from '@tauri-apps/api/core';
 import { mount, unmount } from 'svelte';
 import StartupShell from './StartupShell.svelte';
 import { installDiagnostics, reportDiagnostic, reportError, reportInfo } from './lib/diagnostics';
-import { createInterfaceScaleController, type InterfaceScaleController } from './lib/interfaceScale';
+import {
+    createInterfaceScaleController,
+    type InterfaceScaleController,
+    type InterfaceScaleMode,
+} from './lib/interfaceScale';
 import { prepareServerConnection, prepareStartup } from './lib/startupCoordinator';
 import { frontendStartup, type StartupView } from './lib/startupDiagnostics';
 import { revealAfterInterfaceScale } from './lib/startupVisibility';
@@ -68,10 +72,17 @@ async function bootstrap(mountTarget: HTMLElement): Promise<void> {
     const diagnosticsReady = installDiagnostics().finally(() => frontendStartup.markDiagnosticsInstalled());
     const interfaceScalingReady = (async () => {
         if (!isDesktop) return;
+        let initialMode: InterfaceScaleMode = 'auto';
+        try {
+            initialMode = await invoke<InterfaceScaleMode>('desktop_interface_scale_mode');
+        } catch (error) {
+            reportDiagnostic('interface_scale_preference_load_failed', { message: String(error) }, 'warn');
+        }
         try {
             interfaceScaling = await createInterfaceScaleController(
                 createTauriInterfaceScaleAdapter(),
-                window.localStorage,
+                initialMode,
+                (mode) => invoke('set_desktop_interface_scale_mode', { mode }),
                 reportDiagnostic,
             );
         } catch (error) {
@@ -85,6 +96,7 @@ async function bootstrap(mountTarget: HTMLElement): Promise<void> {
     const view: StartupView =
         new URLSearchParams(window.location.search).get('view') === 'allocation' ? 'allocation' : 'workspace';
     if (view === 'allocation') {
+        const connectionReady = isDesktop ? connectServer(false) : Promise.resolve(null);
         try {
             const moduleReady = shellFirstFrame.then(() =>
                 import('./AllocationInspector.svelte').then((module) => {
@@ -92,7 +104,18 @@ async function bootstrap(mountTarget: HTMLElement): Promise<void> {
                     return module;
                 }),
             );
-            const [module] = await Promise.all([moduleReady, diagnosticsReady, interfaceScalingReady]);
+            const [module, connection] = await Promise.all([
+                moduleReady,
+                connectionReady,
+                diagnosticsReady,
+                interfaceScalingReady,
+            ]);
+            if (isDesktop && !connection) {
+                shellStatus = 'unavailable';
+                shellMessage = 'Check the local service or configure a remote axklib-server connection.';
+                await replaceShell();
+                return;
+            }
             if (shell) await unmount(shell);
             mount(module.default, { target: mountTarget });
             frontendStartup.markAppMounted();
diff --git a/apps/axkdeck/tools/build-version.mjs b/apps/axkdeck/tools/build-version.mjs
index 56524c34..15c7228f 100644
--- a/apps/axkdeck/tools/build-version.mjs
+++ b/apps/axkdeck/tools/build-version.mjs
@@ -46,11 +46,15 @@ export function readBuildIdentity(versionMetadataPath, packageBasenamePath) {
         throw new Error('is_prerelease does not match semantic_version');
     }
     if (metadata.is_release) {
-        if (releaseTag !== `v${semanticVersion}`) {
+        if (releaseTag.replace(/^v/, '') !== semanticVersion) {
             throw new Error('release_tag does not match semantic_version');
         }
-    } else if (semanticVersion !== '0.0.0' || releaseTag !== '') {
-        throw new Error('development builds must use semantic version 0.0.0 without a release tag');
+    } else {
+        const isFallbackDevelopment = semanticVersion === '0.0.0' && !metadata.is_prerelease;
+        const isVersionBranch = semanticVersion === `${projectVersion}-pre` && metadata.is_prerelease;
+        if (releaseTag !== '' || (!isFallbackDevelopment && !isVersionBranch)) {
+            throw new Error('development build version metadata is inconsistent');
+        }
     }
 
     const packageText = readFileSync(packageBasenamePath, 'utf8');
diff --git a/apps/axkdeck/tools/build-version.test.mjs b/apps/axkdeck/tools/build-version.test.mjs
index 0b70db7f..cea47702 100644
--- a/apps/axkdeck/tools/build-version.test.mjs
+++ b/apps/axkdeck/tools/build-version.test.mjs
@@ -37,6 +37,25 @@ test('branch builds use source identity for artifacts and 0.0.0 for Tauri', () =
     assert.deepEqual(tauriVersionConfig(identity, 'linux', '12'), { version: '0.0.0' });
 });
 
+test('version branches use their prerelease semantic version and normalized source identity', () => {
+    const identity = fixture(
+        {
+            ...metadataFixture(),
+            semantic_version: '0.3.6-pre',
+            project_version: '0.3.6',
+            major: 0,
+            minor: 3,
+            patch: 6,
+            is_prerelease: true,
+        },
+        'axklib-0.3.6-pre-a1b2c3d',
+    );
+
+    assert.equal(identity.artifactIdentity, '0.3.6-pre-a1b2c3d');
+    assert.equal(identity.desktopPackageBasename, 'axkdeck-0.3.6-pre-a1b2c3d');
+    assert.deepEqual(tauriVersionConfig(identity, 'linux', '12'), { version: '0.3.6-pre' });
+});
+
 test('native package basename accepts one LF- or CRLF-terminated line', () => {
     const directory = mkdtempSync(join(tmpdir(), 'axkdeck-version-newline-'));
     const versionPath = join(directory, 'version.json');
@@ -81,6 +100,26 @@ test('tag builds use complete semantic version while macOS uses numeric bundle f
     });
 });
 
+test('release tags may omit the v prefix', () => {
+    const identity = fixture(
+        {
+            schema_version: 1,
+            semantic_version: '1.2.3',
+            project_version: '1.2.3',
+            major: 1,
+            minor: 2,
+            patch: 3,
+            release_tag: '1.2.3',
+            is_release: true,
+            is_prerelease: false,
+        },
+        'axklib-1.2.3-a1b2c3d',
+    );
+
+    assert.equal(identity.releaseTag, '1.2.3');
+    assert.equal(identity.artifactIdentity, '1.2.3');
+});
+
 test('inconsistent version metadata is rejected', () => {
     assert.throws(
         () =>
diff --git a/apps/server/contracts/openapi-v1.base.json b/apps/server/contracts/openapi-v1.base.json
index c97ec3ac..20370cd9 100644
--- a/apps/server/contracts/openapi-v1.base.json
+++ b/apps/server/contracts/openapi-v1.base.json
@@ -1107,7 +1107,7 @@
       "ImageObjectItem": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["id", "type", "name", "format", "partitionIndex", "partitionName", "volumeName", "categoryName", "entryName", "sizeBytes", "waveform", "sequence"],
+        "required": ["id", "type", "name", "format", "partitionIndex", "partitionName", "volumeName", "categoryName", "entryName", "sizeBytes", "sizeWithDependenciesBytes", "waveform", "sequence"],
         "properties": {
           "id": {"type": "string", "minLength": 1},
           "type": {"type": "string", "minLength": 1, "maxLength": 16},
@@ -1119,6 +1119,7 @@
           "categoryName": {"type": "string"},
           "entryName": {"type": "string"},
           "sizeBytes": {"type": "integer", "minimum": 0, "description": "Complete stored object file or record size, including object metadata and stored payload bytes."},
+          "sizeWithDependenciesBytes": {"type": ["integer", "null"], "minimum": 0, "description": "Deduplicated stored size of this Program, Sample Bank, or Sample and its exact forward dependency closure; null when the closure is unavailable."},
           "waveform": {"oneOf": [{"$ref": "#/components/schemas/WaveDataMetadata"}, {"type": "null"}]},
           "sequence": {"oneOf": [{"$ref": "#/components/schemas/SequenceMetadata"}, {"type": "null"}]}
         }
@@ -1370,16 +1371,33 @@
           "meta": {"$ref": "#/components/schemas/ResponseMeta"}
         }
       },
+      "ImagePartitionCapacity": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["allocatedClusters", "freeClusters", "clusterSizeBytes"],
+        "properties": {
+          "allocatedClusters": {"type": "integer", "minimum": 0},
+          "freeClusters": {"type": "integer", "minimum": 0},
+          "clusterSizeBytes": {"type": "integer", "minimum": 1}
+        }
+      },
       "ImageContentItem": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["id", "parentId", "depth", "partitionIndex", "volumeDirectoryId", "kind", "displayName", "childCount", "objectId", "objectType", "scopeRole", "quality", "basis", "notes", "details"],
+        "required": ["id", "parentId", "depth", "partitionIndex", "volumeDirectoryId", "partitionCapacity", "sizeBytes", "kind", "displayName", "childCount", "objectId", "objectType", "scopeRole", "quality", "basis", "notes", "details"],
         "properties": {
           "id": {"type": "string", "minLength": 1},
           "parentId": {"type": ["string", "null"]},
           "depth": {"type": "integer", "minimum": 0},
           "partitionIndex": {"type": ["integer", "null"], "minimum": 0, "maximum": 255},
           "volumeDirectoryId": {"type": ["integer", "null"], "minimum": 0, "maximum": 4294967295},
+          "partitionCapacity": {
+            "oneOf": [
+              {"$ref": "#/components/schemas/ImagePartitionCapacity"},
+              {"type": "null"}
+            ]
+          },
+          "sizeBytes": {"type": ["integer", "null"], "minimum": 0, "description": "Deduplicated stored size of objects contained by a volume; null for other content nodes or when unavailable."},
           "kind": {"type": "string", "minLength": 1},
           "name": {"type": "string"},
           "displayName": {"type": "string"},
@@ -3889,15 +3907,23 @@
           "inputBindings": {"type": "array", "maxItems": 1024, "items": {"$ref": "#/components/schemas/InputBinding"}}
         }
       },
+      "ImageVolumeDeletionTarget": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["partitionIndex", "volumeName"],
+        "properties": {
+          "partitionIndex": {"type": "integer", "minimum": 0, "maximum": 7},
+          "volumeName": {"type": "string", "minLength": 1, "maxLength": 16}
+        }
+      },
       "ImageVolumeDeletionInspectionRequest": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["imageId", "expectedRevision", "partitionIndex", "volumeName"],
+        "required": ["imageId", "expectedRevision", "targets"],
         "properties": {
           "imageId": {"type": "string", "minLength": 1},
           "expectedRevision": {"type": "integer", "minimum": 1},
-          "partitionIndex": {"type": "integer", "minimum": 0, "maximum": 7},
-          "volumeName": {"type": "string", "minLength": 1}
+          "targets": {"type": "array", "minItems": 1, "maxItems": 1024, "uniqueItems": true, "items": {"$ref": "#/components/schemas/ImageVolumeDeletionTarget"}}
         }
       },
       "ImagePlacementPartitionScope": {
@@ -3990,12 +4016,11 @@
       "ImageVolumeDeletionInspection": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["imageId", "revision", "partitionIndex", "volumeName", "canDelete", "crossingRelationshipCount", "blockers"],
+        "required": ["imageId", "revision", "targets", "canDelete", "crossingRelationshipCount", "blockers"],
         "properties": {
           "imageId": {"type": "string", "minLength": 1},
           "revision": {"type": "integer", "minimum": 1},
-          "partitionIndex": {"type": "integer", "minimum": 0, "maximum": 7},
-          "volumeName": {"type": "string", "minLength": 1},
+          "targets": {"type": "array", "minItems": 1, "maxItems": 1024, "uniqueItems": true, "items": {"$ref": "#/components/schemas/ImageVolumeDeletionTarget"}},
           "canDelete": {"type": "boolean"},
           "crossingRelationshipCount": {"type": "integer", "minimum": 0},
           "blockers": {"type": "array", "maxItems": 16, "items": {"$ref": "#/components/schemas/ImagePlacementIssue"}}
@@ -4021,7 +4046,7 @@
       "ImageObjectDeletionRequest": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["imageId", "expectedRevision", "targetObjectIds", "cleanupObjectIds"],
+        "required": ["imageId", "expectedRevision", "targetObjectIds", "referrerObjectIds", "cleanupObjectIds"],
         "properties": {
           "imageId": {"type": "string", "minLength": 1},
           "expectedRevision": {"type": "integer", "minimum": 1},
@@ -4032,6 +4057,12 @@
             "uniqueItems": true,
             "items": {"type": "string", "minLength": 1}
           },
+          "referrerObjectIds": {
+            "type": "array",
+            "maxItems": 1024,
+            "uniqueItems": true,
+            "items": {"type": "string", "minLength": 1}
+          },
           "cleanupObjectIds": {
             "type": "array",
             "maxItems": 1024,
@@ -4053,7 +4084,7 @@
       "ImageObjectDeletionImpact": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["objectId", "objectType", "objectName", "partitionIndex", "partitionName", "volumeName", "role", "status", "selected", "storedSizeBytes", "freedClusters", "prerequisiteObjectIds", "reason"],
+        "required": ["objectId", "objectType", "objectName", "partitionIndex", "partitionName", "volumeName", "role", "status", "requested", "selected", "storedSizeBytes", "freedClusters", "prerequisiteObjectIds", "reason"],
         "properties": {
           "objectId": {"type": "string", "minLength": 1},
           "objectType": {"enum": ["PROG", "SBAC", "SBNK", "SMPL", "SEQU"]},
@@ -4061,8 +4092,9 @@
           "partitionIndex": {"type": ["integer", "null"], "minimum": 0, "maximum": 255},
           "partitionName": {"type": "string"},
           "volumeName": {"type": "string"},
-          "role": {"enum": ["TARGET", "DEPENDENCY"]},
+          "role": {"enum": ["TARGET", "REFERRER", "DEPENDENCY"]},
           "status": {"enum": ["REQUIRED", "OPTIONAL", "PRESERVED", "BLOCKED"]},
+          "requested": {"type": "boolean"},
           "selected": {"type": "boolean"},
           "storedSizeBytes": {"type": "integer", "minimum": 0},
           "freedClusters": {"type": "integer", "minimum": 0},
@@ -4094,7 +4126,7 @@
       "ImageObjectDeletionInspection": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["canApply", "imageId", "revision", "targetObjectIds", "selectedObjectIds", "impacts", "references", "blockers", "warnings", "estimatedFreedBytes", "estimatedFreedClusters"],
+        "required": ["canApply", "imageId", "revision", "targetObjectIds", "referrerObjectIds", "cleanupObjectIds", "selectedObjectIds", "impacts", "references", "blockers", "warnings", "estimatedFreedBytes", "estimatedFreedClusters"],
         "properties": {
           "canApply": {
             "type": "boolean",
@@ -4109,6 +4141,18 @@
             "uniqueItems": true,
             "items": {"type": "string", "minLength": 1}
           },
+          "referrerObjectIds": {
+            "type": "array",
+            "maxItems": 1024,
+            "uniqueItems": true,
+            "items": {"type": "string", "minLength": 1}
+          },
+          "cleanupObjectIds": {
+            "type": "array",
+            "maxItems": 1024,
+            "uniqueItems": true,
+            "items": {"type": "string", "minLength": 1}
+          },
           "selectedObjectIds": {"type": "array", "items": {"type": "string", "minLength": 1}},
           "impacts": {"type": "array", "minItems": 1, "items": {"$ref": "#/components/schemas/ImageObjectDeletionImpact"}},
           "references": {"type": "array", "items": {"$ref": "#/components/schemas/ImageObjectDeletionReference"}},
diff --git a/apps/server/contracts/openapi-v1.json b/apps/server/contracts/openapi-v1.json
index fbe608ac..619e9f82 100644
--- a/apps/server/contracts/openapi-v1.json
+++ b/apps/server/contracts/openapi-v1.json
@@ -2844,6 +2844,16 @@
               "null"
             ]
           },
+          "partitionCapacity": {
+            "oneOf": [
+              {
+                "$ref": "#/components/schemas/ImagePartitionCapacity"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
           "partitionIndex": {
             "maximum": 255,
             "minimum": 0,
@@ -2863,6 +2873,14 @@
             ],
             "type": "string"
           },
+          "sizeBytes": {
+            "description": "Deduplicated stored size of objects contained by a volume; null for other content nodes or when unavailable.",
+            "minimum": 0,
+            "type": [
+              "integer",
+              "null"
+            ]
+          },
           "volumeDirectoryId": {
             "maximum": 4294967295,
             "minimum": 0,
@@ -2878,6 +2896,8 @@
           "depth",
           "partitionIndex",
           "volumeDirectoryId",
+          "partitionCapacity",
+          "sizeBytes",
           "kind",
           "displayName",
           "childCount",
@@ -3083,9 +3103,13 @@
             "minLength": 1,
             "type": "string"
           },
+          "requested": {
+            "type": "boolean"
+          },
           "role": {
             "enum": [
               "TARGET",
+              "REFERRER",
               "DEPENDENCY"
             ]
           },
@@ -3117,6 +3141,7 @@
           "volumeName",
           "role",
           "status",
+          "requested",
           "selected",
           "storedSizeBytes",
           "freedClusters",
@@ -3138,6 +3163,15 @@
             "description": "True when at least one requested object can be deleted safely",
             "type": "boolean"
           },
+          "cleanupObjectIds": {
+            "items": {
+              "minLength": 1,
+              "type": "string"
+            },
+            "maxItems": 1024,
+            "type": "array",
+            "uniqueItems": true
+          },
           "estimatedFreedBytes": {
             "description": "Allocated storage bytes expected to become free for the selected deletion closure",
             "minimum": 0,
@@ -3165,6 +3199,15 @@
             },
             "type": "array"
           },
+          "referrerObjectIds": {
+            "items": {
+              "minLength": 1,
+              "type": "string"
+            },
+            "maxItems": 1024,
+            "type": "array",
+            "uniqueItems": true
+          },
           "revision": {
             "minimum": 1,
             "type": "integer"
@@ -3198,6 +3241,8 @@
           "imageId",
           "revision",
           "targetObjectIds",
+          "referrerObjectIds",
+          "cleanupObjectIds",
           "selectedObjectIds",
           "impacts",
           "references",
@@ -3334,6 +3379,15 @@
             "minLength": 1,
             "type": "string"
           },
+          "referrerObjectIds": {
+            "items": {
+              "minLength": 1,
+              "type": "string"
+            },
+            "maxItems": 1024,
+            "type": "array",
+            "uniqueItems": true
+          },
           "targetObjectIds": {
             "items": {
               "minLength": 1,
@@ -3349,6 +3403,7 @@
           "imageId",
           "expectedRevision",
           "targetObjectIds",
+          "referrerObjectIds",
           "cleanupObjectIds"
         ],
         "type": "object"
@@ -3479,6 +3534,14 @@
             "minimum": 0,
             "type": "integer"
           },
+          "sizeWithDependenciesBytes": {
+            "description": "Deduplicated stored size of this Program, Sample Bank, or Sample and its exact forward dependency closure; null when the closure is unavailable.",
+            "minimum": 0,
+            "type": [
+              "integer",
+              "null"
+            ]
+          },
           "type": {
             "maxLength": 16,
             "minLength": 1,
@@ -3509,6 +3572,7 @@
           "categoryName",
           "entryName",
           "sizeBytes",
+          "sizeWithDependenciesBytes",
           "waveform",
           "sequence"
         ],
@@ -3569,6 +3633,29 @@
         ],
         "type": "object"
       },
+      "ImagePartitionCapacity": {
+        "additionalProperties": false,
+        "properties": {
+          "allocatedClusters": {
+            "minimum": 0,
+            "type": "integer"
+          },
+          "clusterSizeBytes": {
+            "minimum": 1,
+            "type": "integer"
+          },
+          "freeClusters": {
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "allocatedClusters",
+          "freeClusters",
+          "clusterSizeBytes"
+        ],
+        "type": "object"
+      },
       "ImagePlacementDestination": {
         "additionalProperties": false,
         "properties": {
@@ -7319,25 +7406,24 @@
             "minLength": 1,
             "type": "string"
           },
-          "partitionIndex": {
-            "maximum": 7,
-            "minimum": 0,
-            "type": "integer"
-          },
           "revision": {
             "minimum": 1,
             "type": "integer"
           },
-          "volumeName": {
-            "minLength": 1,
-            "type": "string"
+          "targets": {
+            "items": {
+              "$ref": "#/components/schemas/ImageVolumeDeletionTarget"
+            },
+            "maxItems": 1024,
+            "minItems": 1,
+            "type": "array",
+            "uniqueItems": true
           }
         },
         "required": [
           "imageId",
           "revision",
-          "partitionIndex",
-          "volumeName",
+          "targets",
           "canDelete",
           "crossingRelationshipCount",
           "blockers"
@@ -7355,19 +7441,38 @@
             "minLength": 1,
             "type": "string"
           },
+          "targets": {
+            "items": {
+              "$ref": "#/components/schemas/ImageVolumeDeletionTarget"
+            },
+            "maxItems": 1024,
+            "minItems": 1,
+            "type": "array",
+            "uniqueItems": true
+          }
+        },
+        "required": [
+          "imageId",
+          "expectedRevision",
+          "targets"
+        ],
+        "type": "object"
+      },
+      "ImageVolumeDeletionTarget": {
+        "additionalProperties": false,
+        "properties": {
           "partitionIndex": {
             "maximum": 7,
             "minimum": 0,
             "type": "integer"
           },
           "volumeName": {
+            "maxLength": 16,
             "minLength": 1,
             "type": "string"
           }
         },
         "required": [
-          "imageId",
-          "expectedRevision",
           "partitionIndex",
           "volumeName"
         ],
@@ -17807,6 +17912,7 @@
                     "cleanupObjectIds": [],
                     "expectedRevision": 1,
                     "imageId": "x",
+                    "referrerObjectIds": [],
                     "targetObjectIds": [
                       "x"
                     ]
@@ -17830,6 +17936,7 @@
                       "data": {
                         "blockers": [],
                         "canApply": false,
+                        "cleanupObjectIds": [],
                         "estimatedFreedBytes": 0,
                         "estimatedFreedClusters": 0,
                         "imageId": "x",
@@ -17843,6 +17950,7 @@
                             "partitionName": "x",
                             "prerequisiteObjectIds": [],
                             "reason": "x",
+                            "requested": false,
                             "role": "TARGET",
                             "selected": false,
                             "status": "REQUIRED",
@@ -17851,6 +17959,7 @@
                           }
                         ],
                         "references": [],
+                        "referrerObjectIds": [],
                         "revision": 1,
                         "selectedObjectIds": [],
                         "targetObjectIds": [
@@ -17868,6 +17977,7 @@
                       "data": {
                         "blockers": [],
                         "canApply": false,
+                        "cleanupObjectIds": [],
                         "estimatedFreedBytes": 0,
                         "estimatedFreedClusters": 0,
                         "imageId": "x",
@@ -17881,6 +17991,7 @@
                             "partitionName": "x",
                             "prerequisiteObjectIds": [],
                             "reason": "x",
+                            "requested": false,
                             "role": "TARGET",
                             "selected": false,
                             "status": "REQUIRED",
@@ -17889,6 +18000,7 @@
                           }
                         ],
                         "references": [],
+                        "referrerObjectIds": [],
                         "revision": 1,
                         "selectedObjectIds": [],
                         "targetObjectIds": [
@@ -18217,6 +18329,7 @@
                     "cleanupObjectIds": [],
                     "expectedRevision": 1,
                     "imageId": "x",
+                    "referrerObjectIds": [],
                     "targetObjectIds": [
                       "x"
                     ]
@@ -26059,8 +26172,12 @@
                   "value": {
                     "expectedRevision": 1,
                     "imageId": "x",
-                    "partitionIndex": 0,
-                    "volumeName": "x"
+                    "targets": [
+                      {
+                        "partitionIndex": 0,
+                        "volumeName": "x"
+                      }
+                    ]
                   }
                 }
               },
@@ -26083,9 +26200,13 @@
                         "canDelete": false,
                         "crossingRelationshipCount": 0,
                         "imageId": "x",
-                        "partitionIndex": 0,
                         "revision": 1,
-                        "volumeName": "x"
+                        "targets": [
+                          {
+                            "partitionIndex": 0,
+                            "volumeName": "x"
+                          }
+                        ]
                       },
                       "meta": {
                         "requestId": "request-1"
@@ -26099,9 +26220,13 @@
                         "canDelete": false,
                         "crossingRelationshipCount": 0,
                         "imageId": "x",
-                        "partitionIndex": 0,
                         "revision": 1,
-                        "volumeName": "x"
+                        "targets": [
+                          {
+                            "partitionIndex": 0,
+                            "volumeName": "x"
+                          }
+                        ]
                       },
                       "meta": {
                         "requestId": "request-1",
diff --git a/apps/server/src/server_image_responses.cpp b/apps/server/src/server_image_responses.cpp
index 349d3667..e0136cbf 100644
--- a/apps/server/src/server_image_responses.cpp
+++ b/apps/server/src/server_image_responses.cpp
@@ -238,22 +238,29 @@ crow::response ServerApplication::image_content_response(const crow::request &re
             return images_.content(id, owner, limit, cursor, parent_id);
         },
         [](const axk::app::ImageContentItem &item) {
-            return Json{{"id", item.id},
-                        {"parentId", item.parent_id ? Json(*item.parent_id) : Json{}},
-                        {"depth", item.depth},
-                        {"partitionIndex", item.partition_index ? Json(*item.partition_index) : Json{}},
-                        {"volumeDirectoryId", item.volume_directory_id ? Json(*item.volume_directory_id) : Json{}},
-                        {"kind", item.kind},
-                        {"name", item.name},
-                        {"displayName", item.display_name},
-                        {"childCount", item.child_count},
-                        {"objectId", item.object_id ? Json(*item.object_id) : Json{}},
-                        {"objectType", item.object_type ? Json(*item.object_type) : Json{}},
-                        {"scopeRole", item.scope_role},
-                        {"quality", item.quality},
-                        {"basis", item.basis},
-                        {"notes", item.notes},
-                        {"details", item.details}};
+            return Json{
+                {"id", item.id},
+                {"parentId", item.parent_id ? Json(*item.parent_id) : Json{}},
+                {"depth", item.depth},
+                {"partitionIndex", item.partition_index ? Json(*item.partition_index) : Json{}},
+                {"volumeDirectoryId", item.volume_directory_id ? Json(*item.volume_directory_id) : Json{}},
+                {"partitionCapacity", item.partition_capacity
+                                          ? Json{{"allocatedClusters", item.partition_capacity->allocated_clusters},
+                                                 {"freeClusters", item.partition_capacity->free_clusters},
+                                                 {"clusterSizeBytes", item.partition_capacity->cluster_size_bytes}}
+                                          : Json{}},
+                {"sizeBytes", item.size_bytes ? Json(*item.size_bytes) : Json{}},
+                {"kind", item.kind},
+                {"name", item.name},
+                {"displayName", item.display_name},
+                {"childCount", item.child_count},
+                {"objectId", item.object_id ? Json(*item.object_id) : Json{}},
+                {"objectType", item.object_type ? Json(*item.object_type) : Json{}},
+                {"scopeRole", item.scope_role},
+                {"quality", item.quality},
+                {"basis", item.basis},
+                {"notes", item.notes},
+                {"details", item.details}};
         });
 }
 
@@ -310,6 +317,8 @@ crow::response ServerApplication::image_objects_response(const crow::request &re
                         {"categoryName", item.category_name},
                         {"entryName", item.entry_name},
                         {"sizeBytes", item.stored_size_bytes},
+                        {"sizeWithDependenciesBytes",
+                         item.size_with_dependencies_bytes ? Json(*item.size_with_dependencies_bytes) : Json{}},
                         {"waveform", std::move(waveform)},
                         {"sequence", std::move(sequence)}};
         });
diff --git a/apps/server/src/workspaces.cpp b/apps/server/src/workspaces.cpp
index 2f36f4fc..7655dbf8 100644
--- a/apps/server/src/workspaces.cpp
+++ b/apps/server/src/workspaces.cpp
@@ -310,19 +310,23 @@ axk::app::Result<std::filesystem::path> axk::server::WorkspaceStore::default_pat
     const auto base = detail::environment_variable("APPDATA");
     if (!base || base->empty())
         return std::unexpected(workspace_error("workspace_store_unavailable", "APPDATA is not available"));
-    return std::filesystem::path{*base} / "axkdeck" / "workspaces.json";
+    return std::filesystem::path{*base} / "tphzz" / "axklib-server" / "workspaces.json";
 #elif defined(__APPLE__)
     const auto home = detail::environment_variable("HOME");
     if (!home || home->empty())
         return std::unexpected(workspace_error("workspace_store_unavailable", "HOME is not available"));
-    return std::filesystem::path{*home} / "Library" / "Application Support" / "axkdeck" / "workspaces.json";
+    return std::filesystem::path{*home} / "Library" / "Application Support" / "tphzz" / "axklib-server" /
+           "workspaces.json";
 #else
-    if (const auto base = detail::environment_variable("XDG_CONFIG_HOME"); base && !base->empty())
-        return std::filesystem::path{*base} / "axkdeck" / "workspaces.json";
+    if (const auto base = detail::environment_variable("XDG_CONFIG_HOME"); base && !base->empty()) {
+        const auto config = std::filesystem::path{*base};
+        if (config.is_absolute())
+            return config / "tphzz" / "axklib-server" / "workspaces.json";
+    }
     const auto home = detail::environment_variable("HOME");
     if (!home || home->empty())
         return std::unexpected(workspace_error("workspace_store_unavailable", "HOME is not available"));
-    return std::filesystem::path{*home} / ".config" / "axkdeck" / "workspaces.json";
+    return std::filesystem::path{*home} / ".config" / "tphzz" / "axklib-server" / "workspaces.json";
 #endif
 }
 
diff --git a/apps/server/tests/server_contract_test.cpp b/apps/server/tests/server_contract_test.cpp
index 127f78c3..7f8ad533 100644
--- a/apps/server/tests/server_contract_test.cpp
+++ b/apps/server/tests/server_contract_test.cpp
@@ -167,8 +167,18 @@ TEST(ServerContract, ImageObjectScopeUsesAnOpaqueContentNodeIdentifier) {
 
     const auto &content_item = document.at("components").at("schemas").at("ImageContentItem");
     EXPECT_TRUE(std::ranges::contains(content_item.at("required"), "scopeRole"));
+    EXPECT_TRUE(std::ranges::contains(content_item.at("required"), "partitionCapacity"));
+    EXPECT_TRUE(std::ranges::contains(content_item.at("required"), "sizeBytes"));
+    EXPECT_EQ(content_item.at("properties").at("sizeBytes").at("type"), nlohmann::json::array({"integer", "null"}));
+    const auto &partition_capacity = document.at("components").at("schemas").at("ImagePartitionCapacity");
+    EXPECT_EQ(partition_capacity.at("required"),
+              nlohmann::json::array({"allocatedClusters", "freeClusters", "clusterSizeBytes"}));
     EXPECT_EQ(content_item.at("properties").at("scopeRole").at("enum"),
               nlohmann::json::array({"CONTAINED", "REFERENCE"}));
+    const auto &object_item = document.at("components").at("schemas").at("ImageObjectItem");
+    EXPECT_TRUE(std::ranges::contains(object_item.at("required"), "sizeWithDependenciesBytes"));
+    EXPECT_EQ(object_item.at("properties").at("sizeWithDependenciesBytes").at("type"),
+              nlohmann::json::array({"integer", "null"}));
 }
 
 TEST(ServerContract, SequenceMetadataSeparatesHeaderAndTimelineTempo) {
@@ -696,6 +706,7 @@ TEST(ServerContract, ObjectDeletionUsesBoundedBatchSelectionsAndReportsPartialAp
     const auto request = nlohmann::json{{"imageId", "image-1"},
                                         {"expectedRevision", 4U},
                                         {"targetObjectIds", nlohmann::json::array({"program-1", "sample-1"})},
+                                        {"referrerObjectIds", nlohmann::json::array()},
                                         {"cleanupObjectIds", nlohmann::json::array({"wave-1"})}};
     EXPECT_TRUE(axk::server::validate_openapi_value(document, "ImageObjectDeletionRequest", request));
 
@@ -712,6 +723,8 @@ TEST(ServerContract, ObjectDeletionUsesBoundedBatchSelectionsAndReportsPartialAp
                        {"imageId", "image-1"},
                        {"revision", 4U},
                        {"targetObjectIds", nlohmann::json::array({"program-1", "sample-1"})},
+                       {"referrerObjectIds", nlohmann::json::array()},
+                       {"cleanupObjectIds", nlohmann::json::array({"wave-1"})},
                        {"selectedObjectIds", nlohmann::json::array({"program-1"})},
                        {"impacts", nlohmann::json::array({{{"objectId", "program-1"},
                                                            {"objectType", "PROG"},
@@ -721,6 +734,7 @@ TEST(ServerContract, ObjectDeletionUsesBoundedBatchSelectionsAndReportsPartialAp
                                                            {"volumeName", "Piano"},
                                                            {"role", "TARGET"},
                                                            {"status", "REQUIRED"},
+                                                           {"requested", true},
                                                            {"selected", true},
                                                            {"storedSizeBytes", 512U},
                                                            {"freedClusters", 1U},
@@ -734,6 +748,7 @@ TEST(ServerContract, ObjectDeletionUsesBoundedBatchSelectionsAndReportsPartialAp
                                                            {"volumeName", "Piano"},
                                                            {"role", "TARGET"},
                                                            {"status", "BLOCKED"},
+                                                           {"requested", true},
                                                            {"selected", false},
                                                            {"storedSizeBytes", 512U},
                                                            {"freedClusters", 1U},
@@ -752,20 +767,25 @@ TEST(ServerContract, ObjectDeletionUsesBoundedBatchSelectionsAndReportsPartialAp
 TEST(ServerContract, VolumeDeletionAndScopedPlacementRepairUseSeparateRevisionBoundedContracts) {
     const auto document =
         axk::server::build_openapi_document(axk::server::embedded_openapi(), axk::app::make_operation_registry());
-    const auto deletion_request = nlohmann::json{
-        {"imageId", "image-1"}, {"expectedRevision", 4U}, {"partitionIndex", 0U}, {"volumeName", "Samples"}};
+    const auto targets = nlohmann::json::array(
+        {{{"partitionIndex", 0U}, {"volumeName", "Samples"}}, {{"partitionIndex", 2U}, {"volumeName", "Programs"}}});
+    const auto deletion_request =
+        nlohmann::json{{"imageId", "image-1"}, {"expectedRevision", 4U}, {"targets", targets}};
     EXPECT_TRUE(
         axk::server::validate_openapi_value(document, "ImageVolumeDeletionInspectionRequest", deletion_request));
     auto invalid_partition = deletion_request;
-    invalid_partition["partitionIndex"] = 8U;
+    invalid_partition["targets"][0]["partitionIndex"] = 8U;
     EXPECT_FALSE(
         axk::server::validate_openapi_value(document, "ImageVolumeDeletionInspectionRequest", invalid_partition));
+    auto duplicate_targets = deletion_request;
+    duplicate_targets["targets"].push_back(duplicate_targets["targets"].front());
+    EXPECT_FALSE(
+        axk::server::validate_openapi_value(document, "ImageVolumeDeletionInspectionRequest", duplicate_targets));
 
     const auto deletion_inspection = nlohmann::json{
         {"imageId", "image-1"},
         {"revision", 4U},
-        {"partitionIndex", 0U},
-        {"volumeName", "Samples"},
+        {"targets", targets},
         {"canDelete", false},
         {"crossingRelationshipCount", 1U},
         {"blockers", nlohmann::json::array({{{"code", "KNOWN_RELATIONSHIP_CROSSES_VOLUME"},
diff --git a/apps/server/tests/server_integration_test.py b/apps/server/tests/server_integration_test.py
index 64c8f0ad..6f0cface 100644
--- a/apps/server/tests/server_integration_test.py
+++ b/apps/server/tests/server_integration_test.py
@@ -1881,6 +1881,7 @@ def exercise(server: Path, cli: Path, fixture: Path) -> None:
                 "imageId": image_id,
                 "expectedRevision": 2,
                 "targetObjectIds": [sample["id"]],
+                "referrerObjectIds": [],
                 "cleanupObjectIds": [],
             }
             status, deletion_inspection = http_request(
diff --git a/apps/server/tests/workspaces_test.cpp b/apps/server/tests/workspaces_test.cpp
index 45d7b544..0ce53c1c 100644
--- a/apps/server/tests/workspaces_test.cpp
+++ b/apps/server/tests/workspaces_test.cpp
@@ -29,6 +29,14 @@ class WorkspaceStoreTest : public testing::Test {
     std::filesystem::path store_path_;
 };
 
+TEST(WorkspaceStoreDefaults, UsesVendorScopedConfigurationDirectory) {
+    const auto path = axk::server::WorkspaceStore::default_path();
+    ASSERT_TRUE(path) << path.error().message;
+    EXPECT_EQ(path->filename(), "workspaces.json");
+    EXPECT_EQ(path->parent_path().filename(), "axklib-server");
+    EXPECT_EQ(path->parent_path().parent_path().filename(), "tphzz");
+}
+
 TEST_F(WorkspaceStoreTest, MissingStoreStartsWithoutAnAvailableWorkspace) {
     auto store = axk::server::WorkspaceStore::open(store_path_);
     ASSERT_TRUE(store) << store.error().message;
diff --git a/docs/axklib/compatibility.md b/docs/axklib/compatibility.md
index c0d95a42..7b60d8d2 100644
--- a/docs/axklib/compatibility.md
+++ b/docs/axklib/compatibility.md
@@ -9,15 +9,18 @@ axklib versions four public surfaces independently:
 
 Installed PIMPL classes constrain public object layout, but pre-1.0 releases may
 still change source or binary compatibility. Release builds derive their version
-from a semantic-version Git tag; development builds use product version `0.0.0`.
+from an optionally `v`-prefixed semantic-version Git tag. Recognized version
+branches use the corresponding `MAJOR.MINOR.PATCH-pre` prerelease version; other
+development builds use product version `0.0.0`.
 Supported consumers use C++17 and a documented compiler/runtime combination.
-Source identities such as `main-a1b2c3d` do not change the API compatibility
-version. See [Versioning And Build Identity](versioning.md).
+Source identities such as `main-a1b2c3d` and `0.3.6-pre-a1b2c3d` identify exact
+builds independently of the API compatibility version. See
+[Versioning And Build Identity](versioning.md).
 
 | Reference build | Build toolchain | Architectures |
 | --- | --- | --- |
 | Windows library and CLI | Visual Studio 18 MSVC, dynamic CRT | x64, ARM64 |
-| Linux library and CLI | GCC 14, distribution libstdc++/glibc | x64, ARM64 |
+| Linux library and CLI | Clang 18, LLVM libc++ 18, distribution glibc | x64, ARM64 |
 | macOS library and CLI | Apple Clang from Xcode 16.4 | universal x64 + ARM64 |
 
 A shared library built from source is compatible only with the matching
diff --git a/docs/axklib/names-and-paths.md b/docs/axklib/names-and-paths.md
index e224fdb2..c297478b 100644
--- a/docs/axklib/names-and-paths.md
+++ b/docs/axklib/names-and-paths.md
@@ -172,6 +172,13 @@ Or11 Argent (F002)
 
 ## Content Tree Sorting
 
+For SFS hard-disk images, axkdeck presents partition names and the direct Volume
+children of each partition in bytewise ASCII order. This matches the display
+order observed in the A-series UI: punctuation, digits, uppercase names,
+underscore, and lowercase names retain their byte values as the sort key. This
+is presentation order only; physical partition indexes and on-disk directory
+order remain unchanged.
+
 Within a category, nodes sort by category order (Programs, Sample Banks/Samples,
 Wave Data, Sequences), Program slot number, display name, object type, and
 object key. This keeps Program slots numerically stable. Missing Program targets
diff --git a/docs/axklib/portable-packages.md b/docs/axklib/portable-packages.md
index a166dfff..77864dd9 100644
--- a/docs/axklib/portable-packages.md
+++ b/docs/axklib/portable-packages.md
@@ -181,7 +181,9 @@ mapping. Exact reusable Programs do not consume another slot. When placement is
 needed, the planner proposes the first contiguous free block large enough for
 all imported Programs; if no such block exists but enough slots remain, it
 proposes the lowest free fragmented slots. If the volume lacks enough of its
-128 Program slots, placement is unavailable and the plan remains blocked.
+128 Program slots, placement is unavailable and the plan remains blocked. For
+multi-package imports into one volume, Programs remain grouped in caller package
+order and retain their source slot order within each package.
 
 Suggested placement is advisory until the caller replans with explicit Program
 slot assignments. This makes the accepted plan identity cover the final slot
diff --git a/docs/axklib/server.md b/docs/axklib/server.md
index ab94b3ed..4b8cf2b7 100644
--- a/docs/axklib/server.md
+++ b/docs/axklib/server.md
@@ -34,12 +34,22 @@ but never files, while choosing a workspace. This temporary broad view uses the
 server process's operating-system permissions. Once a directory is committed,
 all normal reads and writes return to the relative-path sandbox above.
 
-Workspace configuration is stored per user at:
+An independently launched server stores workspace configuration per user at:
 
-- `$XDG_CONFIG_HOME/axkdeck/workspaces.json`, or
-  `~/.config/axkdeck/workspaces.json`, on Linux;
-- `%APPDATA%\axkdeck\workspaces.json` on Windows; and
-- `~/Library/Application Support/axkdeck/workspaces.json` on macOS.
+- `$XDG_CONFIG_HOME/tphzz/axklib-server/workspaces.json`, or
+  `~/.config/tphzz/axklib-server/workspaces.json`, on Linux;
+- `%APPDATA%\tphzz\axklib-server\workspaces.json` on Windows; and
+- `~/Library/Application Support/tphzz/axklib-server/workspaces.json` on macOS.
+
+Axkdeck owns the local server process it launches and passes a distinct sidecar
+registry explicitly. That registry is
+`tphzz/axkdeck/axklib-server/workspaces.json` below the platform configuration
+root. Consequently, a standalone local server can run with its own workspace
+configuration without modifying axkdeck's sidecar configuration. A remote
+server likewise keeps its registry on the remote host; axkdeck does not copy or
+reinterpret it.
+
+The earlier unreleased filenames and locations are not read or migrated.
 
 Use `--workspace-store PATH` or the JSON `workspaceStore` setting for a
 deliberate override. Missing directories remain in the registry with an
@@ -244,6 +254,25 @@ file-prefix inspection recognizes Yamaha object data, otherwise `null`.
 Inspection does not decode complete payloads or recurse beyond one related
 disk-folder level.
 
+### Image browsing size accounting
+
+Image object responses expose `sizeBytes` as the complete logical stored size
+of that object file or SFS record, including its object metadata and stored
+payload. Programs, Sample Banks, and Samples also expose
+`sizeWithDependenciesBytes`. This is an exact, deduplicated forward-closure
+total using the same known relationship requirements as portable-package
+export: a Program includes its assigned Sample Banks and Samples, a Sample Bank
+includes its member Samples, and a Sample includes its left and right Wave
+Data. The value is `null` when any required relationship is missing,
+ambiguous, cyclic, or otherwise unavailable; clients must not present an
+incomplete lower bound as an exact total.
+
+Volume content nodes expose nullable `sizeBytes` as the deduplicated sum of all
+contained object sizes. These values describe logical stored bytes and apply to
+all readable media. They do not include SFS cluster rounding, allocation slack,
+or filesystem support structures and therefore must not be used as physical
+free-space or import-capacity figures.
+
 ### Image integrity and mutation admission
 
 Every readable image session advertises `images.validation.issues`. Retrieve
diff --git a/docs/axklib/versioning.md b/docs/axklib/versioning.md
index 2cc526be..b8be3c1a 100644
--- a/docs/axklib/versioning.md
+++ b/docs/axklib/versioning.md
@@ -7,15 +7,16 @@ a build.
 ## Release Version
 
 An official release is built from a detached commit with exactly one valid
-semantic-version tag:
+semantic-version tag. The tag may use either form:
 
 ```text
-vMAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]
+[v]MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]
 ```
 
-Examples include `v1.2.3`, `v1.2.3-rc.1`, and
-`v1.2.3-rc.1+build.4`. The leading `v` belongs to the Git tag and is omitted
-from runtime, SDK, package, and SBOM version strings.
+Examples include `1.2.3`, `v1.2.3`, `1.2.3-rc.1`, and
+`v1.2.3-rc.1+build.4`. An optional leading `v` belongs to the Git tag and is
+omitted from runtime, SDK, package, and SBOM semantic-version strings. The exact
+tag spelling is retained as release metadata and as the GitHub release tag.
 
 The complete semantic version is used by:
 
@@ -32,16 +33,42 @@ numeric version. They use only the `MAJOR.MINOR.PATCH` core. For example,
 `v1.2.3-rc.1+build.4` has semantic version `1.2.3-rc.1+build.4` and CMake
 project version `1.2.3`.
 
-Named-branch builds and source trees without usable Git metadata deliberately
-use product version `0.0.0`. A release version is never guessed from a branch,
-manifest, or tracked literal. The top-level vcpkg manifest therefore does not
-declare an independent axklib version. Axkdeck's `package.json` and
-`Cargo.toml` use the non-authoritative `0.0.0` development placeholder, while
-`tauri.conf.json` deliberately has no tracked version. The desktop build wrapper
-injects the generated native version into Tauri at build time.
+Recognized version branches provide prerelease identity before a release tag
+exists. These branch names are accepted:
+
+```text
+MAJOR.MINOR.PATCH
+vMAJOR.MINOR.PATCH
+release/MAJOR.MINOR.PATCH
+release/vMAJOR.MINOR.PATCH
+feature/MAJOR.MINOR.PATCH
+feature/vMAJOR.MINOR.PATCH
+features/MAJOR.MINOR.PATCH
+features/vMAJOR.MINOR.PATCH
+bugfix/MAJOR.MINOR.PATCH
+bugfix/vMAJOR.MINOR.PATCH
+bugfixes/MAJOR.MINOR.PATCH
+bugfixes/vMAJOR.MINOR.PATCH
+```
+
+They require a strict numeric semantic-version core with no prerelease or build
+suffix. The namespace, when present, must be exactly one of the five listed
+names; arbitrary namespaces and nested paths are ordinary development branches.
+A `0.3.6`, `release/v0.3.6`, or `features/0.3.6` branch produces semantic
+version `0.3.6-pre`, numeric project version `0.3.6`, and clean source identity
+`0.3.6-pre-<short-git-object-id>`. Version-branch builds are prereleases, not
+releases, and have no release tag.
+
+Other named branches and source trees without usable Git metadata deliberately
+use product version `0.0.0`. A release version is never guessed from a manifest
+or tracked literal. The top-level vcpkg manifest therefore does not declare an
+independent axklib version. Axkdeck's `package.json` and `Cargo.toml` use the
+non-authoritative `0.0.0` development placeholder, while `tauri.conf.json`
+deliberately has no tracked version. The desktop build wrapper injects the
+generated native version into Tauri at build time.
 
 In GitHub Actions, the selected workflow ref type is explicit: a branch run is
-always a development build, while a tag run validates `GITHUB_REF_NAME` against
+always a non-release build, while a tag run validates `GITHUB_REF_NAME` against
 `HEAD`. This avoids making version selection depend on how checkout represents
 the ref locally.
 
@@ -52,22 +79,35 @@ development checkout and a release tag requires rerunning CMake.
 
 ## Source Identity
 
-The source identity has the form:
+Clean ordinary branches and release tags use:
+
+```text
+<sanitized-ref>-<short-git-object-id>
+```
+
+Dirty ordinary branches and release tags place `dirty` before the Git object ID:
+
+```text
+<sanitized-ref>-dirty-<short-git-object-id>
+```
+
+Recognized version branches normalize every accepted spelling to one of:
 
 ```text
-<sanitized-ref>-<short-git-object-id>[-mod]
+MAJOR.MINOR.PATCH-pre-<short-git-object-id>
+MAJOR.MINOR.PATCH-pre-dirty-<short-git-object-id>
 ```
 
-`-mod` means the build observed staged, unstaged, deleted, conflicted, or
-untracked non-ignored files. Git object abbreviations contain at least seven
-hexadecimal characters and may be longer when Git needs more characters for
-uniqueness.
+`dirty` means the build observed staged, unstaged, deleted, conflicted, or
+untracked non-ignored files. The Git object ID is always the final identity
+token. Git object abbreviations contain at least seven hexadecimal characters
+and may be longer when Git needs more characters for uniqueness.
 
 The selected ref uses this order:
 
-1. A checked-out named branch.
-2. A GitHub Actions tag ref for a detached tag build.
-3. An exact local tag at detached `HEAD`.
+1. An explicit GitHub Actions branch or tag ref.
+2. A checked-out named branch.
+3. An exact semantic-version tag at detached `HEAD`.
 4. `detached`.
 
 Ref names retain ASCII letters, digits, dots, underscores, and hyphens. Other
@@ -93,6 +133,17 @@ ref: main
 source: clean
 ```
 
+For any recognized clean `0.3.6` version branch, the corresponding fields are:
+
+```text
+axklib 0.3.6-pre-a1b2c3d
+version: 0.3.6-pre
+package: axklib-0.3.6-pre-a1b2c3d
+git: a1b2c3d
+ref: <sanitized branch name>
+source: clean
+```
+
 For a detached `v1.2.3` release build, `version` is `1.2.3` and the ref is
 `v1.2.3`. Other CLI commands do not receive this header, so JSON, CSV, and
 normal command output contracts are unchanged.
@@ -116,14 +167,20 @@ Manual Native CI builds use these names:
 | Build | Example archive stem |
 | --- | --- |
 | Branch CLI Debug | `axklib-cli-main-a1b2c3d-linux-x64-debug` |
+| Dirty branch CLI Debug | `axklib-cli-main-dirty-a1b2c3d-linux-x64-debug` |
+| Version-branch CLI | `axklib-cli-0.3.6-pre-a1b2c3d-linux-x64` |
 | Tagged CLI prerelease | `axklib-cli-1.2.3-rc.1-linux-x64` |
 | Branch axkdeck DEB | `axkdeck-main-a1b2c3d-linux-x64.deb` |
+| Version-branch axkdeck DEB | `axkdeck-0.3.6-pre-a1b2c3d-linux-x64.deb` |
 | Tagged axkdeck NSIS installer | `axkdeck-1.2.3-windows-x64.exe` |
 | Tagged axkdeck prerelease DMG | `axkdeck-1.2.3-rc.1-macos-universal.dmg` |
 
-Branch desktop binaries carry semantic version `0.0.0` plus the same source
+Ordinary branch desktop binaries carry semantic version `0.0.0`. Version-branch
+desktop binaries carry `MAJOR.MINOR.PATCH-pre`. Both carry the same source
 identity as their bundled server. Tagged desktop binaries carry the complete
-semantic version. On macOS, `CFBundleShortVersionString` uses the numeric
+semantic version. The axkdeck About dialog shows only the semantic version for
+a tagged release and the source identity for a non-release build. On macOS,
+`CFBundleShortVersionString` uses the numeric
 `MAJOR.MINOR.PATCH` core and `CFBundleVersion` uses a numeric CI build number,
 while the complete semantic version and source identity remain embedded in the
 application runtime metadata.
diff --git a/library/CMakeLists.txt b/library/CMakeLists.txt
index 81179f16..6cd0953f 100644
--- a/library/CMakeLists.txt
+++ b/library/CMakeLists.txt
@@ -229,6 +229,8 @@ add_library(
   src/alteration_validation.cpp
   src/alteration_volume.cpp
   src/deletion.cpp
+  src/deletion_contract.cpp
+  src/deletion_manifest.cpp
   src/media_build.cpp
   src/media_conversion.cpp
   src/media_floppy_set.cpp
diff --git a/library/cmake/AxkGitBuildInfo.cmake b/library/cmake/AxkGitBuildInfo.cmake
index 305e246b..9d62b85a 100644
--- a/library/cmake/AxkGitBuildInfo.cmake
+++ b/library/cmake/AxkGitBuildInfo.cmake
@@ -1,4 +1,5 @@
 include_guard(GLOBAL)
+include("${CMAKE_CURRENT_LIST_DIR}/AxkVersionRef.cmake")
 
 function(axk_sanitize_git_ref input output_variable)
   string(REGEX REPLACE "[^A-Za-z0-9._-]+" "-" sanitized "${input}")
@@ -18,6 +19,14 @@ function(axk_derive_git_build_info source_directory product_name)
   set(is_dirty OFF)
   set(ref_name "local")
   set(git_executable "")
+  set(github_ref_type "")
+  set(github_ref_name "")
+  if(DEFINED ENV{GITHUB_REF_TYPE})
+    set(github_ref_type "$ENV{GITHUB_REF_TYPE}")
+  endif()
+  if(DEFINED ENV{GITHUB_REF_NAME})
+    set(github_ref_name "$ENV{GITHUB_REF_NAME}")
+  endif()
 
   if(DEFINED AXK_GIT_EXECUTABLE)
     set(git_executable "${AXK_GIT_EXECUTABLE}")
@@ -49,27 +58,22 @@ function(axk_derive_git_build_info source_directory product_name)
       ERROR_QUIET
       OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    if(git_branch_result EQUAL 0 AND NOT git_branch_output STREQUAL "" AND
+    if(github_ref_type STREQUAL "tag" AND NOT github_ref_name STREQUAL "")
+      set(ref_name "${github_ref_name}")
+      set(git_tag "${github_ref_name}")
+      set(is_tagged_release ON)
+    elseif(github_ref_type STREQUAL "branch" AND NOT github_ref_name STREQUAL "")
+      set(ref_name "${github_ref_name}")
+      set(git_branch "${github_ref_name}")
+    elseif(git_branch_result EQUAL 0 AND NOT git_branch_output STREQUAL "" AND
        NOT git_branch_output STREQUAL "HEAD")
       set(ref_name "${git_branch_output}")
       set(git_branch "${git_branch_output}")
-    elseif(DEFINED ENV{GITHUB_REF_TYPE} AND "$ENV{GITHUB_REF_TYPE}" STREQUAL "tag" AND
-           DEFINED ENV{GITHUB_REF_NAME} AND NOT "$ENV{GITHUB_REF_NAME}" STREQUAL "")
-      set(ref_name "$ENV{GITHUB_REF_NAME}")
-      set(git_tag "$ENV{GITHUB_REF_NAME}")
-      set(is_tagged_release ON)
     else()
-      execute_process(
-        COMMAND "${git_executable}" describe --tags --exact-match HEAD
-        WORKING_DIRECTORY "${source_directory}"
-        RESULT_VARIABLE git_tag_result
-        OUTPUT_VARIABLE git_tag_output
-        ERROR_QUIET
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-      if(git_tag_result EQUAL 0 AND NOT git_tag_output STREQUAL "")
-        set(ref_name "${git_tag_output}")
-        set(git_tag "${git_tag_output}")
+      axk_find_exact_semver_tag("${git_executable}" "${source_directory}")
+      if(NOT AXK_EXACT_SEMVER_TAG STREQUAL "")
+        set(ref_name "${AXK_EXACT_SEMVER_TAG}")
+        set(git_tag "${AXK_EXACT_SEMVER_TAG}")
         set(is_tagged_release ON)
       else()
         set(ref_name "detached")
@@ -91,7 +95,17 @@ function(axk_derive_git_build_info source_directory product_name)
   endif()
 
   axk_sanitize_git_ref("${ref_name}" sanitized_ref)
-  set(source_identity "${sanitized_ref}-${git_sha_short}")
+  axk_parse_version_branch("${ref_name}")
+  if(NOT is_tagged_release AND AXK_VERSION_BRANCH_VALID)
+    set(identity_ref "${AXK_VERSION_BRANCH_CORE}-pre")
+  else()
+    set(identity_ref "${sanitized_ref}")
+  endif()
+  if(is_dirty)
+    set(source_identity "${identity_ref}-dirty-${git_sha_short}")
+  else()
+    set(source_identity "${identity_ref}-${git_sha_short}")
+  endif()
   set(package_basename "${product_name}-${source_identity}")
 
   if(git_branch STREQUAL "")
@@ -104,11 +118,6 @@ function(axk_derive_git_build_info source_directory product_name)
   elseif(NOT git_tag STREQUAL "")
     axk_sanitize_git_ref("${git_tag}" git_tag)
   endif()
-  if(is_dirty)
-    string(APPEND source_identity "-mod")
-    string(APPEND package_basename "-mod")
-  endif()
-
   set(AXK_GIT_TAG "${git_tag}" PARENT_SCOPE)
   set(AXK_GIT_BRANCH "${git_branch}" PARENT_SCOPE)
   set(AXK_GIT_SHA_SHORT "${git_sha_short}" PARENT_SCOPE)
diff --git a/library/cmake/AxkProjectVersion.cmake b/library/cmake/AxkProjectVersion.cmake
index 4d9425d5..5b46399e 100644
--- a/library/cmake/AxkProjectVersion.cmake
+++ b/library/cmake/AxkProjectVersion.cmake
@@ -1,45 +1,5 @@
 include_guard(GLOBAL)
-
-function(axk_parse_semver_tag tag)
-  set(valid OFF)
-  set(major "")
-  set(minor "")
-  set(patch "")
-  set(prerelease "")
-  set(build_metadata "")
-
-  if("${tag}" MATCHES
-     "^v(0|[1-9][0-9]*)[.](0|[1-9][0-9]*)[.](0|[1-9][0-9]*)(-([0-9A-Za-z.-]+))?([+]([0-9A-Za-z.-]+))?$")
-    set(valid ON)
-    set(major "${CMAKE_MATCH_1}")
-    set(minor "${CMAKE_MATCH_2}")
-    set(patch "${CMAKE_MATCH_3}")
-    set(prerelease "${CMAKE_MATCH_5}")
-    set(build_metadata "${CMAKE_MATCH_7}")
-
-    foreach(identifier_group IN ITEMS prerelease build_metadata)
-      if(NOT "${${identifier_group}}" STREQUAL "")
-        string(REPLACE "." ";" identifiers "${${identifier_group}}")
-        foreach(identifier IN LISTS identifiers)
-          if(identifier STREQUAL "" OR NOT identifier MATCHES "^[0-9A-Za-z-]+$")
-            set(valid OFF)
-          endif()
-          if(identifier_group STREQUAL "prerelease" AND
-             identifier MATCHES "^[0-9]+$" AND identifier MATCHES "^0[0-9]+$")
-            set(valid OFF)
-          endif()
-        endforeach()
-      endif()
-    endforeach()
-  endif()
-
-  set(AXK_SEMVER_TAG_VALID "${valid}" PARENT_SCOPE)
-  set(AXK_SEMVER_MAJOR "${major}" PARENT_SCOPE)
-  set(AXK_SEMVER_MINOR "${minor}" PARENT_SCOPE)
-  set(AXK_SEMVER_PATCH "${patch}" PARENT_SCOPE)
-  set(AXK_SEMVER_PRERELEASE "${prerelease}" PARENT_SCOPE)
-  set(AXK_SEMVER_BUILD_METADATA "${build_metadata}" PARENT_SCOPE)
-endfunction()
+include("${CMAKE_CURRENT_LIST_DIR}/AxkVersionRef.cmake")
 
 function(axk_derive_project_version source_directory)
   set(semantic_version "0.0.0")
@@ -66,7 +26,11 @@ function(axk_derive_project_version source_directory)
     endif()
   endif()
 
-  set(named_branch OFF)
+  set(branch_name "")
+  if(github_ref_type STREQUAL "branch" AND DEFINED ENV{GITHUB_REF_NAME} AND
+     NOT "$ENV{GITHUB_REF_NAME}" STREQUAL "")
+    set(branch_name "$ENV{GITHUB_REF_NAME}")
+  endif()
   if(NOT git_executable STREQUAL "")
     execute_process(
       COMMAND "${git_executable}" rev-parse --abbrev-ref HEAD
@@ -76,9 +40,9 @@ function(axk_derive_project_version source_directory)
       ERROR_QUIET
       OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    if(branch_result EQUAL 0 AND NOT branch_output STREQUAL "" AND
-       NOT branch_output STREQUAL "HEAD")
-      set(named_branch ON)
+    if(branch_name STREQUAL "" AND branch_result EQUAL 0 AND
+       NOT branch_output STREQUAL "" AND NOT branch_output STREQUAL "HEAD")
+      set(branch_name "${branch_output}")
     endif()
   endif()
 
@@ -91,12 +55,12 @@ function(axk_derive_project_version source_directory)
       message(FATAL_ERROR "GitHub tag builds require GITHUB_REF_NAME")
     endif()
     set(candidate_tag "$ENV{GITHUB_REF_NAME}")
-    axk_parse_semver_tag("${candidate_tag}")
-    if(NOT AXK_SEMVER_TAG_VALID)
+    axk_parse_semver_ref("${candidate_tag}")
+    if(NOT AXK_SEMVER_REF_VALID)
       message(FATAL_ERROR "GitHub ref '${candidate_tag}' is not a valid semantic version tag")
     endif()
     execute_process(
-      COMMAND "${git_executable}" rev-parse --verify "${candidate_tag}^{commit}"
+      COMMAND "${git_executable}" rev-parse --verify "refs/tags/${candidate_tag}^{commit}"
       WORKING_DIRECTORY "${source_directory}"
       RESULT_VARIABLE tag_commit_result
       OUTPUT_VARIABLE tag_commit
@@ -115,39 +79,20 @@ function(axk_derive_project_version source_directory)
        NOT tag_commit STREQUAL head_commit)
       message(FATAL_ERROR "GitHub release tag '${candidate_tag}' does not identify HEAD")
     endif()
-    set(selected_tag "${candidate_tag}")
-  elseif(NOT github_ref_type STREQUAL "branch" AND NOT named_branch AND
-         NOT git_executable STREQUAL "")
-    execute_process(
-      COMMAND "${git_executable}" tag --points-at HEAD
-      WORKING_DIRECTORY "${source_directory}"
-      RESULT_VARIABLE tags_result
-      OUTPUT_VARIABLE tags_output
-      ERROR_QUIET
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-    set(version_tags)
-    if(tags_result EQUAL 0 AND NOT tags_output STREQUAL "")
-      string(REPLACE "\n" ";" exact_tags "${tags_output}")
-      foreach(candidate_tag IN LISTS exact_tags)
-        axk_parse_semver_tag("${candidate_tag}")
-        if(AXK_SEMVER_TAG_VALID)
-          list(APPEND version_tags "${candidate_tag}")
-        endif()
-      endforeach()
-    endif()
-    list(LENGTH version_tags version_tag_count)
-    if(version_tag_count GREATER 1)
-      list(JOIN version_tags ", " version_tag_list)
-      message(FATAL_ERROR "HEAD has multiple semantic version tags: ${version_tag_list}")
-    elseif(version_tag_count EQUAL 1)
-      list(GET version_tags 0 selected_tag)
+    axk_find_exact_semver_tag("${git_executable}" "${source_directory}")
+    if(NOT AXK_EXACT_SEMVER_TAG STREQUAL "${candidate_tag}")
+      message(FATAL_ERROR
+        "GitHub release tag '${candidate_tag}' is not the exact semantic version tag at HEAD")
     endif()
+    set(selected_tag "${candidate_tag}")
+  elseif(branch_name STREQUAL "" AND NOT git_executable STREQUAL "")
+    axk_find_exact_semver_tag("${git_executable}" "${source_directory}")
+    set(selected_tag "${AXK_EXACT_SEMVER_TAG}")
   endif()
 
   if(NOT selected_tag STREQUAL "")
-    axk_parse_semver_tag("${selected_tag}")
-    string(SUBSTRING "${selected_tag}" 1 -1 semantic_version)
+    axk_parse_semver_ref("${selected_tag}")
+    set(semantic_version "${AXK_SEMVER_NORMALIZED}")
     set(version_major "${AXK_SEMVER_MAJOR}")
     set(version_minor "${AXK_SEMVER_MINOR}")
     set(version_patch "${AXK_SEMVER_PATCH}")
@@ -158,6 +103,17 @@ function(axk_derive_project_version source_directory)
     if(NOT version_prerelease STREQUAL "")
       set(is_prerelease ON)
     endif()
+  elseif(NOT branch_name STREQUAL "")
+    axk_parse_version_branch("${branch_name}")
+    if(AXK_VERSION_BRANCH_VALID)
+      set(semantic_version "${AXK_VERSION_BRANCH_CORE}-pre")
+      set(project_version "${AXK_VERSION_BRANCH_CORE}")
+      set(version_major "${AXK_VERSION_BRANCH_MAJOR}")
+      set(version_minor "${AXK_VERSION_BRANCH_MINOR}")
+      set(version_patch "${AXK_VERSION_BRANCH_PATCH}")
+      set(version_prerelease pre)
+      set(is_prerelease ON)
+    endif()
   endif()
 
   set(AXK_SEMANTIC_VERSION "${semantic_version}" PARENT_SCOPE)
diff --git a/library/cmake/AxkVersionRef.cmake b/library/cmake/AxkVersionRef.cmake
new file mode 100644
index 00000000..c2cf355b
--- /dev/null
+++ b/library/cmake/AxkVersionRef.cmake
@@ -0,0 +1,111 @@
+include_guard(GLOBAL)
+
+function(axk_parse_semver_ref ref)
+  set(valid OFF)
+  set(major "")
+  set(minor "")
+  set(patch "")
+  set(prerelease "")
+  set(build_metadata "")
+  set(normalized "")
+
+  if("${ref}" MATCHES
+     "^v?(0|[1-9][0-9]*)[.](0|[1-9][0-9]*)[.](0|[1-9][0-9]*)(-([0-9A-Za-z.-]+))?([+]([0-9A-Za-z.-]+))?$")
+    set(valid ON)
+    set(major "${CMAKE_MATCH_1}")
+    set(minor "${CMAKE_MATCH_2}")
+    set(patch "${CMAKE_MATCH_3}")
+    set(prerelease "${CMAKE_MATCH_5}")
+    set(build_metadata "${CMAKE_MATCH_7}")
+
+    foreach(identifier_group IN ITEMS prerelease build_metadata)
+      if(NOT "${${identifier_group}}" STREQUAL "")
+        string(REPLACE "." ";" identifiers "${${identifier_group}}")
+        foreach(identifier IN LISTS identifiers)
+          if(identifier STREQUAL "" OR NOT identifier MATCHES "^[0-9A-Za-z-]+$")
+            set(valid OFF)
+          endif()
+          if(identifier_group STREQUAL "prerelease" AND
+             identifier MATCHES "^[0-9]+$" AND identifier MATCHES "^0[0-9]+$")
+            set(valid OFF)
+          endif()
+        endforeach()
+      endif()
+    endforeach()
+
+    if(valid)
+      set(normalized "${major}.${minor}.${patch}")
+      if(NOT prerelease STREQUAL "")
+        string(APPEND normalized "-${prerelease}")
+      endif()
+      if(NOT build_metadata STREQUAL "")
+        string(APPEND normalized "+${build_metadata}")
+      endif()
+    endif()
+  endif()
+
+  set(AXK_SEMVER_REF_VALID "${valid}" PARENT_SCOPE)
+  set(AXK_SEMVER_NORMALIZED "${normalized}" PARENT_SCOPE)
+  set(AXK_SEMVER_MAJOR "${major}" PARENT_SCOPE)
+  set(AXK_SEMVER_MINOR "${minor}" PARENT_SCOPE)
+  set(AXK_SEMVER_PATCH "${patch}" PARENT_SCOPE)
+  set(AXK_SEMVER_PRERELEASE "${prerelease}" PARENT_SCOPE)
+  set(AXK_SEMVER_BUILD_METADATA "${build_metadata}" PARENT_SCOPE)
+endfunction()
+
+function(axk_parse_version_branch ref)
+  set(candidate "${ref}")
+  if(candidate MATCHES "^(release|feature|features|bugfix|bugfixes)/(.+)$")
+    set(candidate "${CMAKE_MATCH_2}")
+  endif()
+
+  axk_parse_semver_ref("${candidate}")
+  if(AXK_SEMVER_REF_VALID AND AXK_SEMVER_PRERELEASE STREQUAL "" AND
+     AXK_SEMVER_BUILD_METADATA STREQUAL "")
+    set(valid ON)
+    set(core "${AXK_SEMVER_MAJOR}.${AXK_SEMVER_MINOR}.${AXK_SEMVER_PATCH}")
+  else()
+    set(valid OFF)
+    set(core "")
+  endif()
+
+  set(AXK_VERSION_BRANCH_VALID "${valid}" PARENT_SCOPE)
+  set(AXK_VERSION_BRANCH_CORE "${core}" PARENT_SCOPE)
+  set(AXK_VERSION_BRANCH_MAJOR "${AXK_SEMVER_MAJOR}" PARENT_SCOPE)
+  set(AXK_VERSION_BRANCH_MINOR "${AXK_SEMVER_MINOR}" PARENT_SCOPE)
+  set(AXK_VERSION_BRANCH_PATCH "${AXK_SEMVER_PATCH}" PARENT_SCOPE)
+endfunction()
+
+function(axk_find_exact_semver_tag git_executable source_directory)
+  execute_process(
+    COMMAND "${git_executable}" tag --points-at HEAD
+    WORKING_DIRECTORY "${source_directory}"
+    RESULT_VARIABLE tags_result
+    OUTPUT_VARIABLE tags_output
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+  set(version_tags)
+  if(tags_result EQUAL 0 AND NOT tags_output STREQUAL "")
+    string(REPLACE "\n" ";" exact_tags "${tags_output}")
+    foreach(candidate_tag IN LISTS exact_tags)
+      axk_parse_semver_ref("${candidate_tag}")
+      if(AXK_SEMVER_REF_VALID)
+        list(APPEND version_tags "${candidate_tag}")
+      endif()
+    endforeach()
+  endif()
+
+  list(LENGTH version_tags version_tag_count)
+  if(version_tag_count GREATER 1)
+    list(JOIN version_tags ", " version_tag_list)
+    message(FATAL_ERROR "HEAD has multiple semantic version tags: ${version_tag_list}")
+  elseif(version_tag_count EQUAL 1)
+    list(GET version_tags 0 selected_tag)
+  else()
+    set(selected_tag "")
+  endif()
+
+  set(AXK_EXACT_SEMVER_TAG "${selected_tag}" PARENT_SCOPE)
+endfunction()
diff --git a/library/cmake/TestBuildInfoGeneration.cmake b/library/cmake/TestBuildInfoGeneration.cmake
index 56688b60..5cb86f2f 100644
--- a/library/cmake/TestBuildInfoGeneration.cmake
+++ b/library/cmake/TestBuildInfoGeneration.cmake
@@ -23,6 +23,12 @@ function(run_git repository)
 endfunction()
 
 function(generate repository output_cpp output_package output_metadata)
+  set(expected_semantic 0.0.0)
+  set(expected_project 0.0.0)
+  if(ARGC EQUAL 6)
+    set(expected_semantic "${ARGV4}")
+    set(expected_project "${ARGV5}")
+  endif()
   execute_process(
     COMMAND
       "${CMAKE_COMMAND}" -E env --unset=GITHUB_REF_TYPE --unset=GITHUB_REF_NAME
@@ -35,8 +41,8 @@ function(generate repository output_cpp output_package output_metadata)
       "-DAXK_VERSION_OUTPUT_CPP=${output_cpp}"
       "-DAXK_VERSION_OUTPUT_PACKAGE=${output_package}"
       "-DAXK_VERSION_OUTPUT_METADATA=${output_metadata}"
-      -DAXK_VERSION_EXPECTED_SEMANTIC=0.0.0
-      -DAXK_VERSION_EXPECTED_PROJECT=0.0.0
+      "-DAXK_VERSION_EXPECTED_SEMANTIC=${expected_semantic}"
+      "-DAXK_VERSION_EXPECTED_PROJECT=${expected_project}"
       "-DAXK_VERSION_GIT_EXECUTABLE=${GIT_EXECUTABLE}"
       -P "${AXK_BUILD_INFO_GENERATOR}"
     RESULT_VARIABLE result
@@ -116,12 +122,12 @@ execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep 1)
 generate("${repository}" "${output_cpp}" "${output_package}" "${output_metadata}")
 file(READ "${output_cpp}" dirty_cpp)
 file(READ "${output_package}" dirty_package)
-if(initial_cpp STREQUAL dirty_cpp OR NOT dirty_cpp MATCHES "-mod")
+if(initial_cpp STREQUAL dirty_cpp OR NOT dirty_cpp MATCHES "-dirty-[0-9a-f]+")
   message(FATAL_ERROR "dirty source did not refresh generated C++ metadata")
 endif()
 string(STRIP "${dirty_package}" dirty_package_basename)
 if(NOT dirty_package STREQUAL "${dirty_package_basename}\n" OR
-   NOT dirty_package_basename MATCHES "-mod$")
+   NOT dirty_package_basename MATCHES "-dirty-[0-9a-f]+$")
   message(FATAL_ERROR "dirty source did not refresh package basename")
 endif()
 
@@ -137,6 +143,30 @@ if(NOT restored_metadata STREQUAL initial_metadata)
   message(FATAL_ERROR "clean source changed version metadata")
 endif()
 
+run_git("${repository}" checkout -b release/v2.3.4)
+generate(
+  "${repository}"
+  "${output_cpp}"
+  "${output_package}"
+  "${output_metadata}"
+  2.3.4-pre
+  2.3.4
+)
+file(READ "${output_package}" version_branch_package)
+string(STRIP "${version_branch_package}" version_branch_package_basename)
+if(NOT version_branch_package STREQUAL "${version_branch_package_basename}\n" OR
+   NOT version_branch_package_basename MATCHES "^axklib-2[.]3[.]4-pre-[0-9a-f]+$")
+  message(FATAL_ERROR "unexpected version-branch package basename: ${version_branch_package}")
+endif()
+file(READ "${output_metadata}" version_branch_metadata)
+string(JSON version_branch_semantic GET "${version_branch_metadata}" semantic_version)
+string(JSON version_branch_release GET "${version_branch_metadata}" is_release)
+if(NOT version_branch_semantic STREQUAL "2.3.4-pre" OR version_branch_release)
+  message(FATAL_ERROR "unexpected version-branch metadata: ${version_branch_metadata}")
+endif()
+run_git("${repository}" checkout main)
+generate("${repository}" "${output_cpp}" "${output_package}" "${output_metadata}")
+
 run_git("${repository}" checkout --detach)
 run_git("${repository}" tag v1.2.3)
 expect_generation_failure(
diff --git a/library/cmake/TestGitBuildInfo.cmake b/library/cmake/TestGitBuildInfo.cmake
index 7f5ea6c5..4088470d 100644
--- a/library/cmake/TestGitBuildInfo.cmake
+++ b/library/cmake/TestGitBuildInfo.cmake
@@ -65,9 +65,44 @@ assert_equal("${AXK_GIT_BRANCH}" main "named branch")
 assert_false("${AXK_IS_TAGGED_RELEASE}" "named branch tag state")
 assert_false("${AXK_GIT_DIRTY}" "clean named branch")
 
+set(version_branches
+  9.8.7
+  v9.8.7
+  release/9.8.7
+  release/v9.8.7
+  feature/9.8.7
+  feature/v9.8.7
+  features/9.8.7
+  features/v9.8.7
+  bugfix/9.8.7
+  bugfix/v9.8.7
+  bugfixes/9.8.7
+  bugfixes/v9.8.7
+)
+foreach(version_branch IN LISTS version_branches)
+  run_git("${repository}" checkout -B "${version_branch}" main)
+  axk_derive_git_build_info("${repository}" axklib)
+  assert_equal("${AXK_SOURCE_IDENTITY}" "9.8.7-pre-${short_sha}" "version branch identity")
+  assert_equal("${AXK_PACKAGE_BASENAME}" "axklib-9.8.7-pre-${short_sha}" "version branch package")
+endforeach()
+
+run_git("${repository}" checkout -B feature/9.8.7 main)
+file(WRITE "${repository}/untracked.txt" "dirty\n")
+axk_derive_git_build_info("${repository}" axklib)
+assert_equal("${AXK_SOURCE_IDENTITY}" "9.8.7-pre-dirty-${short_sha}" "dirty version branch identity")
+assert_equal("${AXK_PACKAGE_BASENAME}" "axklib-9.8.7-pre-dirty-${short_sha}" "dirty version branch package")
+assert_true("${AXK_GIT_DIRTY}" "dirty version branch")
+file(REMOVE "${repository}/untracked.txt")
+
+run_git("${repository}" checkout -B hotfix/9.8.7 main)
+axk_derive_git_build_info("${repository}" axklib)
+assert_equal("${AXK_SOURCE_IDENTITY}" "hotfix-9.8.7-${short_sha}" "non-version namespace identity")
+run_git("${repository}" checkout main)
+
 file(WRITE "${repository}/untracked.txt" "dirty\n")
 axk_derive_git_build_info("${repository}" axklib)
-assert_equal("${AXK_SOURCE_IDENTITY}" "main-${short_sha}-mod" "dirty identity")
+assert_equal("${AXK_SOURCE_IDENTITY}" "main-dirty-${short_sha}" "dirty identity")
+assert_equal("${AXK_PACKAGE_BASENAME}" "axklib-main-dirty-${short_sha}" "dirty package")
 assert_true("${AXK_GIT_DIRTY}" "untracked file dirtiness")
 file(REMOVE "${repository}/untracked.txt")
 
@@ -78,15 +113,24 @@ assert_false("${AXK_IS_TAGGED_RELEASE}" "branch wins tag state")
 
 run_git("${repository}" checkout --detach)
 axk_derive_git_build_info("${repository}" axklib)
-assert_equal("${AXK_SOURCE_IDENTITY}" "preview-${short_sha}" "lightweight exact tag")
-assert_equal("${AXK_GIT_TAG}" preview "lightweight tag value")
-assert_true("${AXK_IS_TAGGED_RELEASE}" "lightweight tag state")
+assert_equal("${AXK_SOURCE_IDENTITY}" "detached-${short_sha}" "non-version exact tag")
+assert_equal("${AXK_GIT_TAG}" "" "non-version tag value")
+assert_false("${AXK_IS_TAGGED_RELEASE}" "non-version tag state")
 
 run_git("${repository}" tag -d preview)
 axk_derive_git_build_info("${repository}" axklib)
 assert_equal("${AXK_SOURCE_IDENTITY}" "detached-${short_sha}" "detached identity")
 assert_equal("${AXK_GIT_BRANCH}" detached "detached branch")
 
+set(ENV{GITHUB_REF_TYPE} branch)
+set(ENV{GITHUB_REF_NAME} "features/v9.8.7")
+axk_derive_git_build_info("${repository}" axklib)
+assert_equal("${AXK_SOURCE_IDENTITY}" "9.8.7-pre-${short_sha}" "GitHub version branch identity")
+assert_equal("${AXK_GIT_BRANCH}" features-v9.8.7 "GitHub version branch")
+assert_false("${AXK_IS_TAGGED_RELEASE}" "GitHub version branch tag state")
+unset(ENV{GITHUB_REF_TYPE})
+unset(ENV{GITHUB_REF_NAME})
+
 set(ENV{GITHUB_REF_TYPE} tag)
 set(ENV{GITHUB_REF_NAME} "nightly/test")
 axk_derive_git_build_info("${repository}" axklib)
@@ -102,6 +146,12 @@ axk_derive_git_build_info("${repository}" axklib)
 assert_equal("${AXK_SOURCE_IDENTITY}" "v1.2.3-${short_sha}" "annotated exact tag")
 assert_equal("${AXK_GIT_TAG}" v1.2.3 "annotated tag value")
 
+run_git("${repository}" tag -d v1.2.3)
+run_git("${repository}" tag -a 1.2.3 -m release)
+axk_derive_git_build_info("${repository}" axklib)
+assert_equal("${AXK_SOURCE_IDENTITY}" "1.2.3-${short_sha}" "unprefixed exact tag")
+assert_equal("${AXK_GIT_TAG}" 1.2.3 "unprefixed exact tag value")
+
 if(DEFINED ENV{RUNNER_TEMP} AND NOT "$ENV{RUNNER_TEMP}" STREQUAL "")
   set(external_temporary_root "$ENV{RUNNER_TEMP}")
 elseif(WIN32 AND DEFINED ENV{TEMP} AND NOT "$ENV{TEMP}" STREQUAL "")
diff --git a/library/cmake/TestProjectVersion.cmake b/library/cmake/TestProjectVersion.cmake
index bda7f855..8afc5ac1 100644
--- a/library/cmake/TestProjectVersion.cmake
+++ b/library/cmake/TestProjectVersion.cmake
@@ -97,6 +97,40 @@ unset(ENV{GITHUB_REF_NAME})
 axk_derive_project_version("${repository}")
 assert_resolution(0.0.0 0.0.0 0 0 0 "" OFF)
 
+set(version_branches
+  9.8.7
+  v9.8.7
+  release/9.8.7
+  release/v9.8.7
+  feature/9.8.7
+  feature/v9.8.7
+  features/9.8.7
+  features/v9.8.7
+  bugfix/9.8.7
+  bugfix/v9.8.7
+  bugfixes/9.8.7
+  bugfixes/v9.8.7
+)
+foreach(version_branch IN LISTS version_branches)
+  run_git("${repository}" checkout -B "${version_branch}" main)
+  axk_derive_project_version("${repository}")
+  assert_resolution(9.8.7-pre 9.8.7 9 8 7 "" ON)
+endforeach()
+
+set(non_version_branches
+  v09.8.7
+  hotfix/9.8.7
+  feature/team/9.8.7
+  feature/9.8.7-rc.1
+  features/9.8.7+build.1
+)
+foreach(non_version_branch IN LISTS non_version_branches)
+  run_git("${repository}" checkout -B "${non_version_branch}" main)
+  axk_derive_project_version("${repository}")
+  assert_resolution(0.0.0 0.0.0 0 0 0 "" OFF)
+endforeach()
+run_git("${repository}" checkout main)
+
 run_git("${repository}" tag v9.8.7)
 axk_derive_project_version("${repository}")
 assert_resolution(0.0.0 0.0.0 0 0 0 "" OFF)
@@ -107,11 +141,22 @@ assert_resolution(9.8.7 9.8.7 9 8 7 v9.8.7 OFF)
 unset(ENV{GITHUB_REF_TYPE})
 unset(ENV{GITHUB_REF_NAME})
 
+run_git("${repository}" tag -d v9.8.7)
+run_git("${repository}" tag 4.5.6)
+set(ENV{GITHUB_REF_TYPE} tag)
+set(ENV{GITHUB_REF_NAME} 4.5.6)
+axk_derive_project_version("${repository}")
+assert_resolution(4.5.6 4.5.6 4 5 6 4.5.6 OFF)
+unset(ENV{GITHUB_REF_TYPE})
+unset(ENV{GITHUB_REF_NAME})
+run_git("${repository}" tag -d 4.5.6)
+run_git("${repository}" tag v9.8.7)
+
 run_git("${repository}" checkout --detach)
 set(ENV{GITHUB_REF_TYPE} branch)
-set(ENV{GITHUB_REF_NAME} main)
+set(ENV{GITHUB_REF_NAME} features/v9.8.7)
 axk_derive_project_version("${repository}")
-assert_resolution(0.0.0 0.0.0 0 0 0 "" OFF)
+assert_resolution(9.8.7-pre 9.8.7 9 8 7 "" ON)
 unset(ENV{GITHUB_REF_TYPE})
 unset(ENV{GITHUB_REF_NAME})
 axk_derive_project_version("${repository}")
@@ -130,6 +175,11 @@ axk_derive_project_version("${repository}")
 assert_resolution("1.2.3-rc.4+build.9" 1.2.3 1 2 3 "v1.2.3-rc.4+build.9" ON)
 
 run_git("${repository}" tag -d "v1.2.3-rc.4+build.9")
+run_git("${repository}" tag 1.2.3)
+axk_derive_project_version("${repository}")
+assert_resolution(1.2.3 1.2.3 1 2 3 1.2.3 OFF)
+run_git("${repository}" tag -d 1.2.3)
+
 run_git("${repository}" tag v01.2.3)
 axk_derive_project_version("${repository}")
 assert_resolution(0.0.0 0.0.0 0 0 0 "" OFF)
@@ -145,6 +195,25 @@ unset(ENV{GITHUB_REF_NAME})
 
 run_git("${repository}" tag v2.4.7)
 expect_resolution_failure("${repository}" "multiple semantic version tags")
+execute_process(
+  COMMAND
+    "${CMAKE_COMMAND}" -E env GITHUB_REF_TYPE=tag GITHUB_REF_NAME=v2.4.6-beta.2
+    "${CMAKE_COMMAND}"
+    "-DAXK_PROJECT_VERSION_MODULE=${AXK_PROJECT_VERSION_MODULE}"
+    "-DAXK_TEST_ROOT=${AXK_TEST_ROOT}"
+    "-DAXK_TEST_FAILURE_REPOSITORY=${repository}"
+    -P "${CMAKE_CURRENT_LIST_FILE}"
+  RESULT_VARIABLE ambiguous_github_tag_result
+  OUTPUT_VARIABLE ambiguous_github_tag_output
+  ERROR_VARIABLE ambiguous_github_tag_error
+)
+if(ambiguous_github_tag_result EQUAL 0 OR
+   NOT "${ambiguous_github_tag_output}${ambiguous_github_tag_error}" MATCHES
+       "multiple semantic version tags")
+  message(FATAL_ERROR
+    "expected ambiguous GitHub tag failure, found:\n"
+    "${ambiguous_github_tag_output}${ambiguous_github_tag_error}")
+endif()
 
 run_git("${repository}" tag -d v2.4.7)
 execute_process(
diff --git a/library/include/axklib/deletion.hpp b/library/include/axklib/deletion.hpp
index 1fb696a9..7a2a5d3f 100644
--- a/library/include/axklib/deletion.hpp
+++ b/library/include/axklib/deletion.hpp
@@ -13,7 +13,7 @@
 
 namespace axk {
 
-enum class ObjectDeletionRole : std::uint8_t { target, dependency };
+enum class ObjectDeletionRole : std::uint8_t { target, referrer, dependency };
 enum class ObjectDeletionStatus : std::uint8_t { required, optional, preserved, blocked };
 enum class ObjectDeletionReferenceEffect : std::uint8_t { blocking, removed, preserved };
 
@@ -32,6 +32,7 @@ struct ObjectDeletionImpact {
     std::string volume_name;
     ObjectDeletionRole role{ObjectDeletionRole::dependency};
     ObjectDeletionStatus status{ObjectDeletionStatus::preserved};
+    bool requested{};
     bool selected{};
     std::uint64_t stored_size_bytes{};
     std::uint64_t freed_clusters{};
@@ -49,6 +50,7 @@ struct ObjectDeletionReference {
 
 struct ObjectDeletionSelection {
     std::vector<std::string> target_keys;
+    std::vector<std::string> referrer_keys;
     std::vector<std::string> cleanup_keys;
 };
 
diff --git a/library/internal/axklib/deletion_manifest.hpp b/library/internal/axklib/deletion_manifest.hpp
new file mode 100644
index 00000000..0181b6b6
--- /dev/null
+++ b/library/internal/axklib/deletion_manifest.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <cstdint>
+#include <span>
+
+#include "axklib/deletion.hpp"
+
+namespace axk::detail {
+
+struct ObjectDeletionManifestPlan {
+    AlterationManifest manifest;
+    std::uint64_t estimated_freed_bytes{};
+    std::uint64_t estimated_freed_clusters{};
+};
+
+Result<ObjectDeletionManifestPlan> build_object_deletion_manifest(const Container &container,
+                                                                  const ObjectCatalog &catalog,
+                                                                  std::span<const ObjectDeletionImpact> impacts);
+
+} // namespace axk::detail
diff --git a/library/internal/axklib/package_closure.hpp b/library/internal/axklib/package_closure.hpp
new file mode 100644
index 00000000..8a1403a3
--- /dev/null
+++ b/library/internal/axklib/package_closure.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "axklib/relationship.hpp"
+
+namespace axk::package_internal {
+
+[[nodiscard]] Result<std::vector<const Relationship *>>
+required_relationships(const ObjectSnapshot &object, const RelationshipGraph &graph,
+                       const std::map<std::string, const ObjectSnapshot *, std::less<>> &objects);
+
+} // namespace axk::package_internal
diff --git a/library/src/alteration.cpp b/library/src/alteration.cpp
index e72b48c9..9dc440dc 100644
--- a/library/src/alteration.cpp
+++ b/library/src/alteration.cpp
@@ -42,6 +42,10 @@ Result<TransactionState> prepare_alteration(std::shared_ptr<const RandomAccessRe
     if (!opened)
         return std::unexpected{opened.error()};
     auto state = std::move(*opened);
+    auto deletion_batch = plan_volume_deletion_batch(state, manifest, cancellation);
+    if (!deletion_batch)
+        return std::unexpected{deletion_batch.error()};
+    state.approved_volume_deletion_batch = std::move(*deletion_batch);
     if (progress) {
         progress->report(
             {ProgressPhase::allocating, 0U, manifest.operations.size(), std::string{initial_message}, progress_path});
diff --git a/library/src/alteration_internal.hpp b/library/src/alteration_internal.hpp
index c7d167a9..14acb114 100644
--- a/library/src/alteration_internal.hpp
+++ b/library/src/alteration_internal.hpp
@@ -46,12 +46,15 @@ struct MutablePartition {
     std::map<SfsId, InsertedRecord> changed;
 };
 
+using PartitionObjectSet = std::set<std::pair<PartitionIndex, SfsId>>;
+
 struct TransactionState {
     std::shared_ptr<const RandomAccessReader> source;
     Container container;
     ObjectCatalog catalog;
     RelationshipGraph graph;
     std::vector<std::tuple<PartitionIndex, SfsId, SfsId>> known_edges;
+    std::optional<PartitionObjectSet> approved_volume_deletion_batch;
     std::map<std::uint8_t, MutablePartition> partitions;
     std::vector<OperationReport> reports;
 };
@@ -127,6 +130,9 @@ Result<void> remove_directory_entry(TransactionState &state, MutablePartition &p
                                     std::string_view name, const CancellationToken &cancellation);
 Result<PartitionIndex> resolve_partition(const TransactionState &state, const PartitionSelector &selector);
 Result<std::set<SfsId>> volume_closure(const Partition &partition, const DirectoryEntry &volume);
+Result<std::optional<PartitionObjectSet>> plan_volume_deletion_batch(const TransactionState &state,
+                                                                     const AlterationManifest &manifest,
+                                                                     const CancellationToken &cancellation);
 
 std::vector<SfsId> free_ids(const MutablePartition &partition, std::size_t count);
 Result<std::vector<Extent>> allocate_extents(MutablePartition &partition, std::uint32_t count);
diff --git a/library/src/alteration_publication.cpp b/library/src/alteration_publication.cpp
index c9a1fb1a..f5027b0b 100644
--- a/library/src/alteration_publication.cpp
+++ b/library/src/alteration_publication.cpp
@@ -412,7 +412,7 @@ Result<TransactionState> open_transaction_state(std::shared_ptr<const RandomAcce
     auto container = open_image(source, source_path, options);
     if (!container)
         return std::unexpected{container.error()};
-    TransactionState state{std::move(source), std::move(*container), {}, {}, {}, {}, {}};
+    TransactionState state{std::move(source), std::move(*container), {}, {}, {}, {}, {}, {}};
     if (state.container.superblock().sector_size_bytes != 512U) {
         return std::unexpected{
             transaction_error("source sector size is outside the supported 512-byte alteration profile")};
diff --git a/library/src/alteration_volume.cpp b/library/src/alteration_volume.cpp
index 9ca0b331..192ce307 100644
--- a/library/src/alteration_volume.cpp
+++ b/library/src/alteration_volume.cpp
@@ -17,6 +17,57 @@
 
 namespace axk::alteration_internal {
 
+Result<std::optional<PartitionObjectSet>> plan_volume_deletion_batch(const TransactionState &state,
+                                                                     const AlterationManifest &manifest,
+                                                                     const CancellationToken &cancellation) {
+    const auto direct_deletions = std::ranges::all_of(manifest.operations, [](const AlterationOperation &operation) {
+        const auto *deletion = std::get_if<DeleteVolumeOperation>(&operation.data);
+        return deletion != nullptr && std::holds_alternative<PartitionIndex>(deletion->partition);
+    });
+    if (!direct_deletions)
+        return std::optional<PartitionObjectSet>{};
+
+    std::set<std::pair<std::uint8_t, std::string>> targets;
+    PartitionObjectSet closure_union;
+    for (const auto &typed_operation : manifest.operations) {
+        if (const auto checked = cancellation.check(); !checked)
+            return std::unexpected{checked.error()};
+        const auto &operation = std::get<DeleteVolumeOperation>(typed_operation.data);
+        const auto partition_index = std::get<PartitionIndex>(operation.partition);
+        if (!targets.emplace(partition_index.value, operation.volume_name).second) {
+            return std::unexpected{transaction_error("volume deletion targets must be unique")};
+        }
+        const auto partition_state = state.partitions.find(partition_index.value);
+        if (partition_state == state.partitions.end()) {
+            return std::unexpected{transaction_error("partition index does not exist")};
+        }
+        const auto &partition = *partition_state->second.source;
+        const auto *root = record(partition, SfsId{1U});
+        if (root == nullptr || root->payload_kind != PayloadKind::directory) {
+            return std::unexpected{transaction_error("partition root directory is unavailable")};
+        }
+        std::vector<const DirectoryEntry *> matches;
+        for (const auto &entry : root->directory_entries) {
+            if (entry.state == DirectoryEntryState::live && entry.name == operation.volume_name)
+                matches.push_back(&entry);
+        }
+        if (matches.size() != 1U) {
+            return std::unexpected{transaction_error("volume name is not unique in the selected partition")};
+        }
+        auto closure = volume_closure(partition, *matches.front());
+        if (!closure)
+            return std::unexpected{closure.error()};
+        for (const auto id : *closure)
+            closure_union.emplace(partition_index, id);
+    }
+    for (const auto &[partition, source, target] : state.known_edges) {
+        if (closure_union.contains({partition, source}) != closure_union.contains({partition, target})) {
+            return std::unexpected{transaction_error("a known object relationship crosses the volume deletion batch")};
+        }
+    }
+    return std::optional<PartitionObjectSet>{std::move(closure_union)};
+}
+
 Result<OperationReport> delete_volume(TransactionState &state, OperationContext context,
                                       const DeleteVolumeOperation &operation, const CancellationToken &cancellation) {
     if (const auto check = cancellation.check(); !check)
@@ -47,31 +98,35 @@ Result<OperationReport> delete_volume(TransactionState &state, OperationContext
     if (!closure)
         return std::unexpected{closure.error()};
 
-    std::map<std::string, SfsId> ids;
-    for (const auto &object : state.catalog.objects) {
-        if (object.partition.value == partition.index.value)
-            ids.emplace(object.key, object.sfs_id);
-    }
-    for (const auto &relation : state.graph.relationships) {
-        if (relation.quality != RelationshipQuality::known || !relation.target_key)
-            continue;
-        const auto source = ids.find(relation.source_key);
-        const auto target = ids.find(*relation.target_key);
-        if (source == ids.end() || target == ids.end())
-            continue;
-        if (closure->contains(source->second) != closure->contains(target->second)) {
-            return std::unexpected{transaction_error("a known object relationship crosses the volume closure")};
+    if (state.approved_volume_deletion_batch) {
+        const auto outside_batch = std::ranges::any_of(*closure, [&](const SfsId id) {
+            return !state.approved_volume_deletion_batch->contains({partition.index, id});
+        });
+        if (outside_batch) {
+            return std::unexpected{transaction_error("volume deletion is outside the approved batch")};
+        }
+    } else {
+        for (const auto &[edge_partition, source, target] : state.known_edges) {
+            if (edge_partition == partition.index && closure->contains(source) != closure->contains(target)) {
+                return std::unexpected{transaction_error("a known object relationship crosses the volume closure")};
+            }
         }
     }
     auto payload = current_root_payload(state, mutable_partition, cancellation);
     if (!payload)
         return std::unexpected{payload.error()};
-    const auto offset = matches.front()->payload_relative_offset;
-    if (offset > payload->size() || payload->size() - offset < 32U) {
-        return std::unexpected{transaction_error("volume directory entry lies outside the root payload")};
+    auto current_entries = parse_directory(*payload, SfsId{1});
+    if (!current_entries)
+        return std::unexpected{current_entries.error()};
+    const auto current = std::ranges::find_if(*current_entries, [&](const ParsedDirectoryEntry &entry) {
+        return entry.state == DirectoryEntryState::live && entry.name == operation.volume_name &&
+               entry.target_sfs_id == SfsId{matches.front()->target_link_id->value};
+    });
+    if (current == current_entries->end()) {
+        return std::unexpected{transaction_error("volume directory entry is absent from transaction state")};
     }
-    payload->erase(payload->begin() + static_cast<std::ptrdiff_t>(offset),
-                   payload->begin() + static_cast<std::ptrdiff_t>(offset + 32U));
+    payload->erase(payload->begin() + static_cast<std::ptrdiff_t>(current->offset),
+                   payload->begin() + static_cast<std::ptrdiff_t>(current->offset + 32U));
     if (auto replaced = set_root_payload(state, mutable_partition, std::move(*payload), cancellation); !replaced)
         return std::unexpected{replaced.error()};
     std::uint64_t freed{};
diff --git a/library/src/deletion.cpp b/library/src/deletion.cpp
index b74f233f..c3556c20 100644
--- a/library/src/deletion.cpp
+++ b/library/src/deletion.cpp
@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "axklib/bytes.hpp"
+#include "axklib/deletion_manifest.hpp"
 #include "axklib/semantic.hpp"
 
 namespace {
@@ -429,51 +430,71 @@ std::vector<std::string> prerequisites(const DeletionIndex &index, const axk::Ob
     return {result.begin(), result.end()};
 }
 
-} // namespace
-
-std::string_view axk::object_deletion_role_name(ObjectDeletionRole role) noexcept {
-    switch (role) {
-    case ObjectDeletionRole::target:
-        return "TARGET";
-    case ObjectDeletionRole::dependency:
-        return "DEPENDENCY";
+std::set<std::string> direct_referrers(const DeletionIndex &index, const axk::ObjectSnapshot &object) {
+    std::set<std::string> result;
+    if (const auto incoming = index.incoming.find(object.key); incoming != index.incoming.end()) {
+        for (const auto *relationship : incoming->second) {
+            if (relevant_incoming(object.object.header.type, relationship->type))
+                result.insert(relationship->source_key);
+        }
     }
-    return "DEPENDENCY";
+    if (const auto *sample = std::get_if<axk::CurrentSbnk>(&object.object.payload)) {
+        for (const auto number : sample->linked_program_numbers) {
+            if (const auto key = index.program_key(object, number))
+                result.insert(*key);
+        }
+    }
+    return result;
 }
 
-std::string_view axk::object_deletion_status_name(ObjectDeletionStatus status) noexcept {
-    switch (status) {
-    case ObjectDeletionStatus::required:
-        return "REQUIRED";
-    case ObjectDeletionStatus::optional:
-        return "OPTIONAL";
-    case ObjectDeletionStatus::preserved:
-        return "PRESERVED";
-    case ObjectDeletionStatus::blocked:
-        return "BLOCKED";
-    }
-    return "BLOCKED";
+std::set<std::string> reachable_referrers(const DeletionIndex &index, const std::set<std::string> &targets) {
+    std::set<std::string> result;
+    std::vector<std::string> pending(targets.begin(), targets.end());
+    for (std::size_t cursor = 0; cursor < pending.size(); ++cursor) {
+        const auto *object = index.find(pending[cursor]);
+        if (object == nullptr)
+            continue;
+        for (const auto &key : direct_referrers(index, *object)) {
+            const auto *referrer = index.find(key);
+            if (referrer == nullptr || !supported_type(referrer->object.header.type) || targets.contains(key) ||
+                !index.same_scope(*object, *referrer)) {
+                continue;
+            }
+            if (result.insert(key).second)
+                pending.push_back(key);
+        }
+    }
+    return result;
 }
 
-std::string_view axk::object_deletion_reference_effect_name(ObjectDeletionReferenceEffect effect) noexcept {
-    switch (effect) {
-    case ObjectDeletionReferenceEffect::blocking:
-        return "BLOCKING";
-    case ObjectDeletionReferenceEffect::removed:
-        return "REMOVED";
-    case ObjectDeletionReferenceEffect::preserved:
-        return "PRESERVED";
+std::set<std::string> contributing_referrers(const DeletionIndex &index, const std::set<std::string> &eligible_targets,
+                                             const std::set<std::string> &available) {
+    std::set<std::string> result;
+    std::vector<std::string> pending(eligible_targets.begin(), eligible_targets.end());
+    for (std::size_t cursor = 0; cursor < pending.size(); ++cursor) {
+        const auto *object = index.find(pending[cursor]);
+        if (object == nullptr)
+            continue;
+        for (const auto &key : direct_referrers(index, *object)) {
+            if (!available.contains(key))
+                continue;
+            if (result.insert(key).second)
+                pending.push_back(key);
+        }
     }
-    return "PRESERVED";
+    return result;
 }
 
+} // namespace
+
 axk::Result<axk::ObjectDeletionInspection> axk::inspect_object_deletion(const Container &container,
                                                                         const ObjectCatalog &catalog,
                                                                         const RelationshipGraph &graph,
                                                                         const ObjectDeletionSelection &selection) {
     if (selection.target_keys.empty())
         return std::unexpected(deletion_error("deletion requires at least one target"));
-    if (selection.target_keys.size() + selection.cleanup_keys.size() > maximum_deletion_objects)
+    if (selection.target_keys.size() + selection.referrer_keys.size() + selection.cleanup_keys.size() >
+        maximum_deletion_objects)
         return std::unexpected(deletion_error("deletion selection exceeds the 1024 object limit"));
 
     const DeletionIndex index{container, catalog, graph};
@@ -489,26 +510,63 @@ axk::Result<axk::ObjectDeletionInspection> axk::inspect_object_deletion(const Co
             return std::unexpected(deletion_error("deletion targets must be unique"));
     }
     std::set<std::string> requested_cleanup;
+    std::set<std::string> requested_referrers;
+    for (const auto &key : selection.referrer_keys) {
+        if (requested_targets.contains(key) || !requested_referrers.insert(key).second)
+            return std::unexpected(deletion_error("referrer objects must be unique and exclude deletion targets"));
+        if (index.find(key) == nullptr)
+            return std::unexpected(deletion_error("referrer object does not exist"));
+    }
     for (const auto &key : selection.cleanup_keys) {
-        if (requested_targets.contains(key) || !requested_cleanup.insert(key).second)
-            return std::unexpected(deletion_error("cleanup objects must be unique and exclude deletion targets"));
+        if (requested_targets.contains(key) || requested_referrers.contains(key) ||
+            !requested_cleanup.insert(key).second)
+            return std::unexpected(
+                deletion_error("cleanup objects must be unique and exclude deletion targets and referrers"));
         if (index.find(key) == nullptr)
             return std::unexpected(deletion_error("cleanup object does not exist"));
     }
 
     ObjectDeletionInspection result;
     result.target_keys.assign(requested_targets.begin(), requested_targets.end());
-    result.manifest.schema_version = std::string{alteration_manifest_schema_version};
 
-    const auto eligible_targets = stable_deletion_set(index, requested_targets);
+    const auto upstream = reachable_referrers(index, requested_targets);
+    for (const auto &key : requested_referrers) {
+        if (!upstream.contains(key))
+            return std::unexpected(deletion_error("referrer object is not in the target reference closure"));
+    }
+
+    auto complete_candidates = requested_targets;
+    complete_candidates.insert(upstream.begin(), upstream.end());
+    const auto complete_stable = stable_deletion_set(index, complete_candidates);
+    std::set<std::string> completely_eligible_targets;
+    std::ranges::copy_if(requested_targets,
+                         std::inserter(completely_eligible_targets, completely_eligible_targets.end()),
+                         [&](const auto &key) { return complete_stable.contains(key); });
+    const auto optional_referrers = contributing_referrers(index, completely_eligible_targets, complete_stable);
+
+    auto explicit_candidates = requested_targets;
+    explicit_candidates.insert(requested_referrers.begin(), requested_referrers.end());
+    const auto explicit_stable = stable_deletion_set(index, explicit_candidates);
+    std::set<std::string> eligible_targets;
+    std::ranges::copy_if(requested_targets, std::inserter(eligible_targets, eligible_targets.end()),
+                         [&](const auto &key) { return explicit_stable.contains(key); });
+    const auto selected_referrers = contributing_referrers(index, eligible_targets, explicit_stable);
+    auto selected = eligible_targets;
+    selected.insert(selected_referrers.begin(), selected_referrers.end());
+
     for (const auto &key : requested_targets) {
         const auto *object = index.find(key);
         const auto eligible = eligible_targets.contains(key);
-        result.impacts.push_back(make_impact(container, *object, ObjectDeletionRole::target,
-                                             eligible ? ObjectDeletionStatus::required : ObjectDeletionStatus::blocked,
-                                             eligible ? "Selected object" : "Deletion constraints are not satisfied"));
+        const auto resolvable = completely_eligible_targets.contains(key);
+        auto impact = make_impact(container, *object, ObjectDeletionRole::target,
+                                  eligible ? ObjectDeletionStatus::required : ObjectDeletionStatus::blocked,
+                                  eligible     ? "Selected object"
+                                  : resolvable ? "References must be resolved"
+                                               : "Deletion constraints are not satisfied");
+        impact.requested = true;
+        result.impacts.push_back(std::move(impact));
         if (!eligible) {
-            auto blockers = evaluate_object(index, *object, eligible_targets);
+            auto blockers = evaluate_object(index, *object, explicit_stable);
             if (blockers.empty()) {
                 add_notice(blockers, "DEPENDENCY_BLOCKED", "A selected referencing object cannot be deleted safely",
                            {key});
@@ -518,13 +576,34 @@ axk::Result<axk::ObjectDeletionInspection> axk::inspect_object_deletion(const Co
         }
     }
 
-    const auto reachable = reachable_cleanup(index, eligible_targets, requested_targets);
-    auto potential = eligible_targets;
+    for (const auto &key : upstream) {
+        const auto *object = index.find(key);
+        const auto optional = optional_referrers.contains(key);
+        auto impact = make_impact(container, *object, ObjectDeletionRole::referrer,
+                                  optional ? ObjectDeletionStatus::optional : ObjectDeletionStatus::preserved,
+                                  optional ? std::format("Delete this {} to resolve an incoming reference",
+                                                         object_type_label(object->object.header.type))
+                                           : std::format("This {} cannot safely resolve the selected target",
+                                                         object_type_label(object->object.header.type)));
+        impact.requested = requested_referrers.contains(key);
+        if (optional)
+            impact.prerequisite_keys = prerequisites(index, *object, complete_stable);
+        result.impacts.push_back(std::move(impact));
+    }
+
+    auto cleanup_sources = requested_targets;
+    cleanup_sources.insert(selected_referrers.begin(), selected_referrers.end());
+    auto cleanup_excluded = requested_targets;
+    cleanup_excluded.insert(upstream.begin(), upstream.end());
+    const auto reachable = reachable_cleanup(index, cleanup_sources, cleanup_excluded);
+    auto potential = completely_eligible_targets;
+    potential.insert(optional_referrers.begin(), optional_referrers.end());
+    const auto protected_keys = potential;
     potential.insert(reachable.begin(), reachable.end());
-    potential = stable_deletion_set(index, std::move(potential), eligible_targets);
+    potential = stable_deletion_set(index, std::move(potential), protected_keys);
     const std::set<std::string> optional_keys = [&] {
         auto value = potential;
-        for (const auto &key : eligible_targets)
+        for (const auto &key : protected_keys)
             value.erase(key);
         return value;
     }();
@@ -539,6 +618,7 @@ axk::Result<axk::ObjectDeletionInspection> axk::inspect_object_deletion(const Co
                                                          object_type_label(object->object.header.type)));
         if (optional)
             impact.prerequisite_keys = prerequisites(index, *object, potential);
+        impact.requested = requested_cleanup.contains(key);
         result.impacts.push_back(std::move(impact));
     }
 
@@ -546,7 +626,6 @@ axk::Result<axk::ObjectDeletionInspection> axk::inspect_object_deletion(const Co
         if (!optional_keys.contains(key))
             return std::unexpected(deletion_error("cleanup object is not an optional dependency of this deletion"));
     }
-    std::set<std::string> selected = eligible_targets;
     bool changed = true;
     while (changed) {
         changed = false;
@@ -562,17 +641,16 @@ axk::Result<axk::ObjectDeletionInspection> axk::inspect_object_deletion(const Co
             }
         }
     }
-    if (!std::ranges::all_of(requested_cleanup, [&](const auto &key) { return selected.contains(key); }))
-        return std::unexpected(deletion_error("cleanup selection requires every prerequisite object"));
-
     for (auto &impact : result.impacts)
         impact.selected = selected.contains(impact.object_key);
     result.selected_keys.assign(selected.begin(), selected.end());
-    result.can_apply = !selected.empty();
+    result.can_apply = !eligible_targets.empty();
 
     std::ranges::sort(result.impacts, {}, [](const auto &impact) {
         return std::tuple{impact.status == ObjectDeletionStatus::blocked ? 1 : 0,
-                          impact.role == ObjectDeletionRole::target ? 0 : 1,
+                          impact.role == ObjectDeletionRole::target     ? 0
+                          : impact.role == ObjectDeletionRole::referrer ? 1
+                                                                        : 2,
                           impact.partition.value,
                           impact.volume_name,
                           object_type_order(impact.object_type),
@@ -611,61 +689,11 @@ axk::Result<axk::ObjectDeletionInspection> axk::inspect_object_deletion(const Co
         }
     }
 
-    std::vector<const ObjectDeletionImpact *> ordered;
-    for (const auto &impact : result.impacts) {
-        if (impact.selected)
-            ordered.push_back(&impact);
-    }
-    std::ranges::sort(ordered, {}, [](const auto *impact) {
-        return std::tuple{impact->partition.value, impact->volume_name, object_type_order(impact->object_type),
-                          impact->object_name, impact->object_key};
-    });
-    std::size_t program_index{};
-    std::size_t bank_index{};
-    std::size_t sample_index{};
-    std::size_t wave_index{};
-    std::size_t sequence_index{};
-    for (const auto *impact : ordered) {
-        const auto partition = std::ranges::find(container.partitions(), impact->partition, &Partition::index);
-        if (partition == container.partitions().end())
-            return std::unexpected(deletion_error("deletion impact partition is not available"));
-        const auto cluster_size =
-            checked_multiply(container.superblock().sector_size_bytes, partition->sectors_per_cluster);
-        const auto freed_bytes = cluster_size ? checked_multiply(impact->freed_clusters, *cluster_size)
-                                              : Result<std::uint64_t>{std::unexpected{cluster_size.error()}};
-        const auto total_bytes = freed_bytes ? checked_add(result.estimated_freed_bytes, *freed_bytes)
-                                             : Result<std::uint64_t>{std::unexpected{freed_bytes.error()}};
-        const auto total_clusters = checked_add(result.estimated_freed_clusters, impact->freed_clusters);
-        if (!total_bytes || !total_clusters)
-            return std::unexpected(deletion_error("deletion recovery estimate exceeds supported limits"));
-        result.estimated_freed_bytes = *total_bytes;
-        result.estimated_freed_clusters = *total_clusters;
-
-        const auto *object = index.find(impact->object_key);
-        if (impact->object_type == ObjectType::prog) {
-            const auto number = object == nullptr ? std::nullopt : program_number(*object);
-            if (!number)
-                return std::unexpected(deletion_error("selected Program number is unreadable"));
-            result.manifest.operations.push_back(
-                {std::format("delete-program-{}", ++program_index),
-                 DeleteProgramOperation{impact->partition, impact->volume_name, *number}});
-        } else if (impact->object_type == ObjectType::sbac) {
-            result.manifest.operations.push_back(
-                {std::format("delete-sample-bank-{}", ++bank_index),
-                 DeleteSampleBankOperation{impact->partition, impact->volume_name, object->object.header.name}});
-        } else if (impact->object_type == ObjectType::sbnk) {
-            result.manifest.operations.push_back(
-                {std::format("delete-sample-{}", ++sample_index),
-                 DeleteSampleOperation{impact->partition, impact->volume_name, object->object.header.name}});
-        } else if (impact->object_type == ObjectType::smpl) {
-            result.manifest.operations.push_back(
-                {std::format("delete-wave-data-{}", ++wave_index),
-                 DeleteWaveformOperation{impact->partition, impact->volume_name, object->object.header.name}});
-        } else {
-            result.manifest.operations.push_back(
-                {std::format("delete-sequence-{}", ++sequence_index),
-                 DeleteSequenceOperation{impact->partition, impact->volume_name, object->object.header.name}});
-        }
-    }
+    const auto manifest = detail::build_object_deletion_manifest(container, catalog, result.impacts);
+    if (!manifest)
+        return std::unexpected(manifest.error());
+    result.manifest = manifest->manifest;
+    result.estimated_freed_bytes = manifest->estimated_freed_bytes;
+    result.estimated_freed_clusters = manifest->estimated_freed_clusters;
     return result;
 }
diff --git a/library/src/deletion_contract.cpp b/library/src/deletion_contract.cpp
new file mode 100644
index 00000000..067091a3
--- /dev/null
+++ b/library/src/deletion_contract.cpp
@@ -0,0 +1,39 @@
+#include "axklib/deletion.hpp"
+
+std::string_view axk::object_deletion_role_name(ObjectDeletionRole role) noexcept {
+    switch (role) {
+    case ObjectDeletionRole::target:
+        return "TARGET";
+    case ObjectDeletionRole::referrer:
+        return "REFERRER";
+    case ObjectDeletionRole::dependency:
+        return "DEPENDENCY";
+    }
+    return "DEPENDENCY";
+}
+
+std::string_view axk::object_deletion_status_name(ObjectDeletionStatus status) noexcept {
+    switch (status) {
+    case ObjectDeletionStatus::required:
+        return "REQUIRED";
+    case ObjectDeletionStatus::optional:
+        return "OPTIONAL";
+    case ObjectDeletionStatus::preserved:
+        return "PRESERVED";
+    case ObjectDeletionStatus::blocked:
+        return "BLOCKED";
+    }
+    return "BLOCKED";
+}
+
+std::string_view axk::object_deletion_reference_effect_name(ObjectDeletionReferenceEffect effect) noexcept {
+    switch (effect) {
+    case ObjectDeletionReferenceEffect::blocking:
+        return "BLOCKING";
+    case ObjectDeletionReferenceEffect::removed:
+        return "REMOVED";
+    case ObjectDeletionReferenceEffect::preserved:
+        return "PRESERVED";
+    }
+    return "PRESERVED";
+}
diff --git a/library/src/deletion_manifest.cpp b/library/src/deletion_manifest.cpp
new file mode 100644
index 00000000..131b801e
--- /dev/null
+++ b/library/src/deletion_manifest.cpp
@@ -0,0 +1,112 @@
+#include "axklib/deletion_manifest.hpp"
+
+#include <algorithm>
+#include <charconv>
+#include <format>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "axklib/bytes.hpp"
+
+namespace {
+
+axk::Error deletion_error(std::string message) {
+    return axk::make_error(axk::ErrorCode::transaction_rejected, axk::ErrorCategory::transaction, std::move(message));
+}
+
+int object_type_order(axk::ObjectType type) {
+    switch (type) {
+    case axk::ObjectType::prog:
+        return 0;
+    case axk::ObjectType::sbac:
+        return 1;
+    case axk::ObjectType::sbnk:
+        return 2;
+    case axk::ObjectType::smpl:
+        return 3;
+    case axk::ObjectType::sequ:
+        return 4;
+    default:
+        return 5;
+    }
+}
+
+std::optional<std::uint8_t> program_number(const axk::ObjectSnapshot &object) {
+    unsigned value{};
+    const auto &name = object.object.header.name;
+    const auto [end, error] = std::from_chars(name.data(), name.data() + name.size(), value);
+    if (error != std::errc{} || end != name.data() + name.size() || value == 0U || value > 128U)
+        return std::nullopt;
+    return static_cast<std::uint8_t>(value);
+}
+
+} // namespace
+
+axk::Result<axk::detail::ObjectDeletionManifestPlan>
+axk::detail::build_object_deletion_manifest(const Container &container, const ObjectCatalog &catalog,
+                                            std::span<const ObjectDeletionImpact> impacts) {
+    ObjectDeletionManifestPlan result;
+    result.manifest.schema_version = std::string{alteration_manifest_schema_version};
+    std::vector<const ObjectDeletionImpact *> ordered;
+    for (const auto &impact : impacts) {
+        if (impact.selected)
+            ordered.push_back(&impact);
+    }
+    std::ranges::sort(ordered, {}, [](const auto *impact) {
+        return std::tuple{impact->partition.value, impact->volume_name, object_type_order(impact->object_type),
+                          impact->object_name, impact->object_key};
+    });
+    std::size_t program_index{};
+    std::size_t bank_index{};
+    std::size_t sample_index{};
+    std::size_t wave_index{};
+    std::size_t sequence_index{};
+    for (const auto *impact : ordered) {
+        const auto partition = std::ranges::find(container.partitions(), impact->partition, &Partition::index);
+        if (partition == container.partitions().end())
+            return std::unexpected(deletion_error("deletion impact partition is not available"));
+        const auto cluster_size =
+            checked_multiply(container.superblock().sector_size_bytes, partition->sectors_per_cluster);
+        const auto freed_bytes = cluster_size ? checked_multiply(impact->freed_clusters, *cluster_size)
+                                              : Result<std::uint64_t>{std::unexpected{cluster_size.error()}};
+        const auto total_bytes = freed_bytes ? checked_add(result.estimated_freed_bytes, *freed_bytes)
+                                             : Result<std::uint64_t>{std::unexpected{freed_bytes.error()}};
+        const auto total_clusters = checked_add(result.estimated_freed_clusters, impact->freed_clusters);
+        if (!total_bytes || !total_clusters)
+            return std::unexpected(deletion_error("deletion recovery estimate exceeds supported limits"));
+        result.estimated_freed_bytes = *total_bytes;
+        result.estimated_freed_clusters = *total_clusters;
+
+        const auto object = std::ranges::find(catalog.objects, impact->object_key, &ObjectSnapshot::key);
+        if (object == catalog.objects.end())
+            return std::unexpected(deletion_error("selected deletion object is not available"));
+        if (impact->object_type == ObjectType::prog) {
+            const auto number = program_number(*object);
+            if (!number)
+                return std::unexpected(deletion_error("selected Program number is unreadable"));
+            result.manifest.operations.push_back(
+                {std::format("delete-program-{}", ++program_index),
+                 DeleteProgramOperation{impact->partition, impact->volume_name, *number}});
+        } else if (impact->object_type == ObjectType::sbac) {
+            result.manifest.operations.push_back(
+                {std::format("delete-sample-bank-{}", ++bank_index),
+                 DeleteSampleBankOperation{impact->partition, impact->volume_name, object->object.header.name}});
+        } else if (impact->object_type == ObjectType::sbnk) {
+            result.manifest.operations.push_back(
+                {std::format("delete-sample-{}", ++sample_index),
+                 DeleteSampleOperation{impact->partition, impact->volume_name, object->object.header.name}});
+        } else if (impact->object_type == ObjectType::smpl) {
+            result.manifest.operations.push_back(
+                {std::format("delete-wave-data-{}", ++wave_index),
+                 DeleteWaveformOperation{impact->partition, impact->volume_name, object->object.header.name}});
+        } else {
+            result.manifest.operations.push_back(
+                {std::format("delete-sequence-{}", ++sequence_index),
+                 DeleteSequenceOperation{impact->partition, impact->volume_name, object->object.header.name}});
+        }
+    }
+    return result;
+}
diff --git a/library/src/package_build.cpp b/library/src/package_build.cpp
index ee26c614..67f53385 100644
--- a/library/src/package_build.cpp
+++ b/library/src/package_build.cpp
@@ -21,13 +21,13 @@
 #include "axklib/audio.hpp"
 #include "axklib/file_publication.hpp"
 #include "axklib/package_archive.hpp"
+#include "axklib/package_closure.hpp"
 #include "axklib/package_relocation.hpp"
 #include "axklib/relationship.hpp"
 #include "axklib/utf8.hpp"
 
 #include "package_internal.hpp"
 #include "package_manifest_internal.hpp"
-#include "relationship_policy.hpp"
 
 namespace axk {
 namespace {
@@ -136,92 +136,6 @@ Result<std::vector<SelectedRoot>> select_roots(const ObjectCatalog &catalog,
     return result;
 }
 
-Result<std::vector<const Relationship *>>
-required_relationships(const ObjectSnapshot &object, const RelationshipGraph &graph,
-                       const std::map<std::string, const ObjectSnapshot *, std::less<>> &objects) {
-    std::vector<const Relationship *> candidates;
-    for (const auto *relationship : graph.children(object.key)) {
-        if (!closure_relationship(relationship->type))
-            continue;
-        if (relationship->type.starts_with("PROG_ASSIGNMENT_TO_") && !is_program_assignment_row(*relationship)) {
-            continue;
-        }
-        candidates.push_back(relationship);
-    }
-
-    const auto require_one = [&](std::string_view role, std::optional<std::size_t> assignment_index =
-                                                            std::nullopt) -> Result<const Relationship *> {
-        std::vector<const Relationship *> matches;
-        for (const auto *row : candidates) {
-            if (row->type == role && (!assignment_index || row->assignment_index == assignment_index))
-                matches.push_back(row);
-        }
-        if (matches.size() != 1U || matches.front()->quality != RelationshipQuality::known ||
-            !matches.front()->target_key) {
-            ErrorContext context;
-            context.object_type = object.object.header.raw_type;
-            context.object_name = object.object.header.name;
-            return std::unexpected{make_error(
-                matches.size() > 1U ? ErrorCode::relationship_ambiguous : ErrorCode::relationship_unresolved,
-                ErrorCategory::relationship, std::format("package closure requires one known {} relationship", role),
-                std::move(context))};
-        }
-        return matches.front();
-    };
-
-    std::vector<const Relationship *> result;
-    if (const auto *sample = std::get_if<CurrentSbnk>(&object.object.payload)) {
-        if (!sample->left.wave_data_name.empty()) {
-            auto row = require_one("SBNK_LEFT_MEMBER_TO_SMPL");
-            if (!row)
-                return std::unexpected{row.error()};
-            result.push_back(*row);
-        }
-        if (sample->right && !sample->right->wave_data_name.empty()) {
-            auto row = require_one("SBNK_RIGHT_MEMBER_TO_SMPL");
-            if (!row)
-                return std::unexpected{row.error()};
-            result.push_back(*row);
-        }
-    } else if (const auto *sample_bank = std::get_if<CurrentSbac>(&object.object.payload)) {
-        const auto active_slots =
-            std::ranges::count_if(sample_bank->slots, [](const SbacSlot &slot) { return !slot.name.empty(); });
-        if (candidates.size() != static_cast<std::size_t>(active_slots)) {
-            return std::unexpected{make_error(ErrorCode::relationship_unresolved, ErrorCategory::relationship,
-                                              "Sample Bank package export cannot resolve every active "
-                                              "Sample member")};
-        }
-        for (const auto *row : candidates) {
-            if (row->type != "SBAC_SLOT_TO_SBNK" || row->quality != RelationshipQuality::known || !row->target_key) {
-                return std::unexpected{make_error(ErrorCode::relationship_unresolved, ErrorCategory::relationship,
-                                                  "Sample Bank package export cannot unambiguously identify "
-                                                  "every Sample member in its source volume")};
-            }
-            result.push_back(row);
-        }
-    } else if (const auto *program = std::get_if<CurrentProg>(&object.object.payload)) {
-        for (std::size_t index = 0; index < program->assignments.size(); ++index) {
-            const auto &assignment = program->assignments[index];
-            if (assignment.name.empty() || (assignment.kind != 0x10U && assignment.kind != 0x11U))
-                continue;
-            const auto role = assignment.kind == 0x11U   ? "PROG_ASSIGNMENT_TO_SBAC"
-                              : assignment.kind == 0x10U ? "PROG_ASSIGNMENT_TO_SBNK"
-                                                         : std::string_view{};
-            const auto unresolved = std::ranges::find_if(candidates, [&](const Relationship *row) {
-                return row->type == role && row->assignment_index == index && !is_effective_program_assignment(*row) &&
-                       !detail::relationship_has_exact_named_program_target(*row, objects);
-            });
-            if (unresolved != candidates.end())
-                continue;
-            auto row = require_one(role, index);
-            if (!row)
-                return std::unexpected{row.error()};
-            result.push_back(*row);
-        }
-    }
-    return result;
-}
-
 PackagePlacementHint placement_hint(const ObjectSnapshot &object) {
     if (!object.placement)
         return {};
@@ -285,7 +199,7 @@ Result<PackageBuild> build_selected_package(const MediaContainer &source, std::s
         const auto profile = package_internal::build_relocation_profile(object->object, object->raw_payload);
         if (!profile)
             return std::unexpected{profile.error()};
-        auto required = required_relationships(*object, graph, objects);
+        auto required = package_internal::required_relationships(*object, graph, objects);
         if (!required)
             return std::unexpected{required.error()};
         std::map<std::string, std::uint32_t, std::less<>> role_ordinals;
diff --git a/library/src/package_import_program_slots.cpp b/library/src/package_import_program_slots.cpp
index 21c7d2ed..a7a2beb9 100644
--- a/library/src/package_import_program_slots.cpp
+++ b/library/src/package_import_program_slots.cpp
@@ -70,8 +70,8 @@ std::vector<PackageProgramSlotPlacement> plan_program_slot_placements(const Prog
     std::vector<PackageProgramSlotPlacement> result;
     for (auto &[destination, candidates] : candidates_by_destination) {
         std::ranges::sort(candidates, [](const auto &left, const auto &right) {
-            return std::tie(left.source_slot, left.package_index, left.node_id) <
-                   std::tie(right.source_slot, right.package_index, right.node_id);
+            return std::tie(left.package_index, left.source_slot, left.node_id) <
+                   std::tie(right.package_index, right.source_slot, right.node_id);
         });
         candidates.erase(std::ranges::unique(candidates, {},
                                              [](const auto &candidate) {
diff --git a/library/src/package_support.cpp b/library/src/package_support.cpp
index 7eb2ed22..f2cb7146 100644
--- a/library/src/package_support.cpp
+++ b/library/src/package_support.cpp
@@ -11,6 +11,9 @@
 
 #include "axklib/audio.hpp"
 #include "axklib/package_archive.hpp"
+#include "axklib/package_closure.hpp"
+
+#include "relationship_policy.hpp"
 
 namespace axk::package_internal {
 
@@ -184,6 +187,88 @@ bool closure_relationship(std::string_view role) {
            role == "PROG_ASSIGNMENT_TO_SBAC" || role == "PROG_ASSIGNMENT_TO_SBNK";
 }
 
+Result<std::vector<const Relationship *>>
+required_relationships(const ObjectSnapshot &object, const RelationshipGraph &graph,
+                       const std::map<std::string, const ObjectSnapshot *, std::less<>> &objects) {
+    std::vector<const Relationship *> candidates;
+    for (const auto *relationship : graph.children(object.key)) {
+        if (!closure_relationship(relationship->type))
+            continue;
+        if (relationship->type.starts_with("PROG_ASSIGNMENT_TO_") && !is_program_assignment_row(*relationship))
+            continue;
+        candidates.push_back(relationship);
+    }
+    const auto require_one = [&](std::string_view role, std::optional<std::size_t> assignment_index =
+                                                            std::nullopt) -> Result<const Relationship *> {
+        std::vector<const Relationship *> matches;
+        for (const auto *row : candidates) {
+            if (row->type == role && (!assignment_index || row->assignment_index == assignment_index))
+                matches.push_back(row);
+        }
+        if (matches.size() != 1U || matches.front()->quality != RelationshipQuality::known ||
+            !matches.front()->target_key) {
+            ErrorContext context;
+            context.object_type = object.object.header.raw_type;
+            context.object_name = object.object.header.name;
+            return std::unexpected{make_error(
+                matches.size() > 1U ? ErrorCode::relationship_ambiguous : ErrorCode::relationship_unresolved,
+                ErrorCategory::relationship, std::format("package closure requires one known {} relationship", role),
+                std::move(context))};
+        }
+        return matches.front();
+    };
+    std::vector<const Relationship *> result;
+    if (const auto *sample = std::get_if<CurrentSbnk>(&object.object.payload)) {
+        if (!sample->left.wave_data_name.empty()) {
+            auto row = require_one("SBNK_LEFT_MEMBER_TO_SMPL");
+            if (!row)
+                return std::unexpected{row.error()};
+            result.push_back(*row);
+        }
+        if (sample->right && !sample->right->wave_data_name.empty()) {
+            auto row = require_one("SBNK_RIGHT_MEMBER_TO_SMPL");
+            if (!row)
+                return std::unexpected{row.error()};
+            result.push_back(*row);
+        }
+    } else if (const auto *sample_bank = std::get_if<CurrentSbac>(&object.object.payload)) {
+        const auto active_slots =
+            std::ranges::count_if(sample_bank->slots, [](const SbacSlot &slot) { return !slot.name.empty(); });
+        if (candidates.size() != static_cast<std::size_t>(active_slots)) {
+            return std::unexpected{make_error(ErrorCode::relationship_unresolved, ErrorCategory::relationship,
+                                              "Sample Bank package export cannot resolve every active Sample member")};
+        }
+        for (const auto *row : candidates) {
+            if (row->type != "SBAC_SLOT_TO_SBNK" || row->quality != RelationshipQuality::known || !row->target_key) {
+                return std::unexpected{make_error(ErrorCode::relationship_unresolved, ErrorCategory::relationship,
+                                                  "Sample Bank package export cannot unambiguously identify every "
+                                                  "Sample member in its source volume")};
+            }
+            result.push_back(row);
+        }
+    } else if (const auto *program = std::get_if<CurrentProg>(&object.object.payload)) {
+        for (std::size_t index = 0; index < program->assignments.size(); ++index) {
+            const auto &assignment = program->assignments[index];
+            if (assignment.name.empty() || (assignment.kind != 0x10U && assignment.kind != 0x11U))
+                continue;
+            const auto role = assignment.kind == 0x11U   ? "PROG_ASSIGNMENT_TO_SBAC"
+                              : assignment.kind == 0x10U ? "PROG_ASSIGNMENT_TO_SBNK"
+                                                         : std::string_view{};
+            const auto unresolved = std::ranges::find_if(candidates, [&](const Relationship *row) {
+                return row->type == role && row->assignment_index == index && !is_effective_program_assignment(*row) &&
+                       !detail::relationship_has_exact_named_program_target(*row, objects);
+            });
+            if (unresolved != candidates.end())
+                continue;
+            auto row = require_one(role, index);
+            if (!row)
+                return std::unexpected{row.error()};
+            result.push_back(*row);
+        }
+    }
+    return result;
+}
+
 Result<std::optional<WaveformDigests>> waveform_digests(const DecodedObject &decoded,
                                                         std::span<const std::byte> raw_payload,
                                                         std::string_view normalized_digest) {
diff --git a/library/tests/alteration_test.cpp b/library/tests/alteration_test.cpp
index af7a5d30..f7b1a380 100644
--- a/library/tests/alteration_test.cpp
+++ b/library/tests/alteration_test.cpp
@@ -858,6 +858,110 @@ TEST(Alteration, DeleteVolumeDryRunMatchesApplyAndPreservesSource) {
     std::filesystem::remove_all(root, error);
 }
 
+TEST(Alteration, DeletesMultipleVolumesFromCurrentRootDirectoryState) {
+    const auto root = std::filesystem::temp_directory_path() / "axklib-alteration-delete-volumes";
+    const auto source = root / "source.hds";
+    std::error_code error;
+    std::filesystem::remove_all(root, error);
+    std::filesystem::create_directories(root);
+    auto build = source_manifest();
+    axk::VolumeSpec survivor;
+    survivor.name = "Survivor";
+    build.partitions[0].volumes.push_back(std::move(survivor));
+    ASSERT_TRUE(axk::write_hds_image(build, source));
+    const auto source_before = bytes(source);
+
+    for (const auto &[first, second] : std::array{std::pair{"Retained", "Removed"}, std::pair{"Removed", "Retained"}}) {
+        const auto output = root / std::format("{}-then-{}.hds", first, second);
+        const axk::AlterationManifest manifest{
+            "1.0",
+            {
+                {"first", axk::DeleteVolumeOperation{axk::PartitionIndex{0U}, first}},
+                {"second", axk::DeleteVolumeOperation{axk::PartitionIndex{0U}, second}},
+            },
+        };
+
+        const auto altered = axk::alter_hds(source, manifest, output);
+        ASSERT_TRUE(altered) << altered.error().message;
+        ASSERT_EQ(altered->operations.size(), 2U);
+        const auto reopened = axk::open_image(output);
+        ASSERT_TRUE(reopened) << reopened.error().message;
+        const auto &root_record =
+            *std::ranges::find(reopened->partitions()[0].records, axk::SfsId{1}, &axk::IndexRecord::sfs_id);
+        EXPECT_TRUE(std::ranges::contains(root_record.directory_entries, "Survivor", &axk::DirectoryEntry::name));
+        EXPECT_FALSE(std::ranges::contains(root_record.directory_entries, "Retained", &axk::DirectoryEntry::name));
+        EXPECT_FALSE(std::ranges::contains(root_record.directory_entries, "Removed", &axk::DirectoryEntry::name));
+        EXPECT_EQ(bytes(source), source_before);
+    }
+    std::filesystem::remove_all(root, error);
+}
+
+TEST(Alteration, PlansVolumeDeletionRelationshipsAcrossTheSelectedBatch) {
+    const auto root = std::filesystem::temp_directory_path() / "axklib-alteration-delete-volume-plan";
+    const auto source = root / "source.hds";
+    std::error_code error;
+    std::filesystem::remove_all(root, error);
+    std::filesystem::create_directories(root);
+    ASSERT_TRUE(axk::write_hds_image(source_manifest(), source));
+    auto state = axk::alteration_internal::open_transaction_state(source, {}, nullptr, true);
+    ASSERT_TRUE(state) << state.error().message;
+    const auto &root_record =
+        *std::ranges::find(state->container.partitions()[0].records, axk::SfsId{1}, &axk::IndexRecord::sfs_id);
+    const auto volume_id = [&](std::string_view name) {
+        const auto found = std::ranges::find(root_record.directory_entries, name, &axk::DirectoryEntry::name);
+        EXPECT_NE(found, root_record.directory_entries.end());
+        return axk::SfsId{found->target_link_id->value};
+    };
+    const auto retained = volume_id("Retained");
+    const auto removed = volume_id("Removed");
+    state->known_edges = {{axk::PartitionIndex{0U}, retained, removed}};
+    const axk::AlterationManifest batch{
+        "1.0",
+        {
+            {"first", axk::DeleteVolumeOperation{axk::PartitionIndex{0U}, "Retained"}},
+            {"second", axk::DeleteVolumeOperation{axk::PartitionIndex{0U}, "Removed"}},
+        },
+    };
+
+    const auto planned = axk::alteration_internal::plan_volume_deletion_batch(*state, batch, {});
+    ASSERT_TRUE(planned) << planned.error().message;
+    ASSERT_TRUE(*planned);
+    EXPECT_TRUE((*planned)->contains({axk::PartitionIndex{0U}, retained}));
+    EXPECT_TRUE((*planned)->contains({axk::PartitionIndex{0U}, removed}));
+
+    const axk::AlterationManifest partial{"1.0",
+                                          {{"only", axk::DeleteVolumeOperation{axk::PartitionIndex{0U}, "Retained"}}}};
+    const auto rejected = axk::alteration_internal::plan_volume_deletion_batch(*state, partial, {});
+    ASSERT_FALSE(rejected);
+    EXPECT_NE(rejected.error().message.find("relationship crosses"), std::string::npos);
+
+    const axk::AlterationManifest duplicate{
+        "1.0",
+        {
+            {"first", axk::DeleteVolumeOperation{axk::PartitionIndex{0U}, "Retained"}},
+            {"second", axk::DeleteVolumeOperation{axk::PartitionIndex{0U}, "Retained"}},
+        },
+    };
+    const auto duplicate_plan = axk::alteration_internal::plan_volume_deletion_batch(*state, duplicate, {});
+    ASSERT_FALSE(duplicate_plan);
+    EXPECT_NE(duplicate_plan.error().message.find("unique"), std::string::npos);
+
+    state->approved_volume_deletion_batch = **planned;
+    const auto first = axk::alteration_internal::delete_volume(
+        *state, {"first", "delete_volume"}, std::get<axk::DeleteVolumeOperation>(batch.operations[0].data), {});
+    ASSERT_TRUE(first) << first.error().message;
+    const auto second = axk::alteration_internal::delete_volume(
+        *state, {"second", "delete_volume"}, std::get<axk::DeleteVolumeOperation>(batch.operations[1].data), {});
+    ASSERT_TRUE(second) << second.error().message;
+    auto root_payload = axk::alteration_internal::current_root_payload(*state, state->partitions.at(0U), {});
+    ASSERT_TRUE(root_payload) << root_payload.error().message;
+    const auto entries = axk::alteration_internal::parse_directory(*root_payload, axk::SfsId{1U});
+    ASSERT_TRUE(entries) << entries.error().message;
+    EXPECT_FALSE(std::ranges::contains(*entries, "Retained", &axk::alteration_internal::ParsedDirectoryEntry::name));
+    EXPECT_FALSE(std::ranges::contains(*entries, "Removed", &axk::alteration_internal::ParsedDirectoryEntry::name));
+    std::filesystem::remove_all(root, error);
+}
+
 TEST(Alteration, RejectsPartitionSupportDirectoryAsAVolumeTarget) {
     const auto root = std::filesystem::temp_directory_path() / "axklib-alteration-reserved-prf3";
     const auto source = root / "source.hds";
diff --git a/library/tests/deletion_test.cpp b/library/tests/deletion_test.cpp
index a5337acc..933c60ae 100644
--- a/library/tests/deletion_test.cpp
+++ b/library/tests/deletion_test.cpp
@@ -154,13 +154,14 @@ TEST(ObjectDeletion, PlansStandaloneSequenceDeletion) {
                                             [](const auto &object) { return object.object.header.type; });
     ASSERT_NE(sequence, catalog->objects.end());
 
-    const auto inspected =
-        axk::inspect_object_deletion(*container, *catalog, graph, {.target_keys = {sequence->key}, .cleanup_keys = {}});
+    const auto inspected = axk::inspect_object_deletion(
+        *container, *catalog, graph, {.target_keys = {sequence->key}, .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
     ASSERT_EQ(inspected->impacts.size(), 1U);
     EXPECT_EQ(inspected->impacts.front().object_type, axk::ObjectType::sequ);
+    EXPECT_TRUE(inspected->impacts.front().requested);
     ASSERT_EQ(inspected->manifest.operations.size(), 1U);
     EXPECT_TRUE(std::holds_alternative<axk::DeleteSequenceOperation>(inspected->manifest.operations.front().data));
     std::filesystem::remove_all(root, error);
@@ -172,8 +173,9 @@ TEST(ObjectDeletion, KeepsDependenciesExplicitAndUncheckedByDefault) {
     const auto &sample = object(fixture, axk::ObjectType::sbnk);
     const auto &wave = object(fixture, axk::ObjectType::smpl);
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = {bank.key}, .cleanup_keys = {}});
+    const auto inspected =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {bank.key}, .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
@@ -222,8 +224,9 @@ TEST(ObjectDeletion, IgnoresStoredProgramRowsWithoutAnEffectiveTarget) {
         .receive_channel_display = "=Smp",
     });
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = {program->key}, .cleanup_keys = {}});
+    const auto inspected =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {program->key}, .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
@@ -240,9 +243,9 @@ TEST(ObjectDeletion, OrdersSelectedDependencyClosureFromParentsToLeaves) {
     const auto &sample = object(fixture, axk::ObjectType::sbnk);
     const auto &wave = object(fixture, axk::ObjectType::smpl);
 
-    const auto inspected =
-        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                     {.target_keys = {bank.key}, .cleanup_keys = {wave.key, sample.key}});
+    const auto inspected = axk::inspect_object_deletion(
+        fixture.container, fixture.catalog, fixture.graph,
+        {.target_keys = {bank.key}, .referrer_keys = {}, .cleanup_keys = {wave.key, sample.key}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
@@ -278,29 +281,110 @@ TEST(ObjectDeletion, BlocksTargetWithIncomingProgramReference) {
     const auto fixture = make_fixture(true);
     const auto &bank = object(fixture, axk::ObjectType::sbac);
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = {bank.key}, .cleanup_keys = {}});
+    const auto inspected =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {bank.key}, .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_FALSE(inspected->can_apply);
     EXPECT_FALSE(inspected->blockers.empty());
     EXPECT_TRUE(inspected->manifest.operations.empty());
+
+    const auto program = object(fixture, axk::ObjectType::prog);
+    const auto referrer = std::ranges::find(inspected->impacts, program.key, &axk::ObjectDeletionImpact::object_key);
+    ASSERT_NE(referrer, inspected->impacts.end());
+    EXPECT_EQ(referrer->role, axk::ObjectDeletionRole::referrer);
+    EXPECT_EQ(referrer->status, axk::ObjectDeletionStatus::optional);
+    EXPECT_FALSE(referrer->requested);
+    EXPECT_FALSE(referrer->selected);
 }
 
-TEST(ObjectDeletion, ResolvesReferencesAcrossAProgramAndSampleBankBatch) {
+TEST(ObjectDeletion, ResolvesAReferencedSampleBankThroughAnExplicitProgramReferrer) {
     const auto fixture = make_fixture(true);
     const auto &program = object(fixture, axk::ObjectType::prog);
     const auto &bank = object(fixture, axk::ObjectType::sbac);
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = {bank.key, program.key}, .cleanup_keys = {}});
+    const auto inspected =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {bank.key}, .referrer_keys = {program.key}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
     EXPECT_TRUE(inspected->blockers.empty());
+    EXPECT_EQ(inspected->target_keys, std::vector<std::string>{bank.key});
     ASSERT_EQ(inspected->manifest.operations.size(), 2U);
     EXPECT_TRUE(std::holds_alternative<axk::DeleteProgramOperation>(inspected->manifest.operations[0].data));
     EXPECT_TRUE(std::holds_alternative<axk::DeleteSampleBankOperation>(inspected->manifest.operations[1].data));
+
+    const auto referrer = std::ranges::find(inspected->impacts, program.key, &axk::ObjectDeletionImpact::object_key);
+    ASSERT_NE(referrer, inspected->impacts.end());
+    EXPECT_TRUE(referrer->requested);
+    EXPECT_TRUE(referrer->selected);
+
+    const auto direct_sample = std::ranges::find(inspected->impacts, "Direct", &axk::ObjectDeletionImpact::object_name);
+    ASSERT_NE(direct_sample, inspected->impacts.end());
+    EXPECT_EQ(direct_sample->role, axk::ObjectDeletionRole::dependency);
+    EXPECT_EQ(direct_sample->status, axk::ObjectDeletionStatus::optional);
+    EXPECT_FALSE(direct_sample->requested);
+    EXPECT_FALSE(direct_sample->selected);
+    EXPECT_EQ(direct_sample->prerequisite_keys, std::vector<std::string>{program.key});
+
+    const auto output = fixture.root / "referrer-deleted.hds";
+    const auto altered = axk::alter_hds(fixture.root / "source.hds", inspected->manifest, output);
+    ASSERT_TRUE(altered) << altered.error().message;
+    const auto reopened = axk::open_image(output);
+    ASSERT_TRUE(reopened) << reopened.error().message;
+    const auto remaining = axk::build_object_catalog(*reopened);
+    ASSERT_TRUE(remaining) << remaining.error().message;
+    EXPECT_EQ(std::ranges::count(remaining->objects, axk::ObjectType::prog,
+                                 [](const auto &item) { return item.object.header.type; }),
+              0U);
+    EXPECT_EQ(std::ranges::count(remaining->objects, axk::ObjectType::sbac,
+                                 [](const auto &item) { return item.object.header.type; }),
+              0U);
+    EXPECT_EQ(std::ranges::count(remaining->objects, axk::ObjectType::sbnk,
+                                 [](const auto &item) { return item.object.header.type; }),
+              2U);
+    EXPECT_EQ(std::ranges::count(remaining->objects, axk::ObjectType::smpl,
+                                 [](const auto &item) { return item.object.header.type; }),
+              1U);
+}
+
+TEST(ObjectDeletion, RequiresTheCompleteRecursiveReferrerChainForASample) {
+    const auto fixture = make_fixture(true);
+    const auto &program = object(fixture, axk::ObjectType::prog);
+    const auto &bank = object(fixture, axk::ObjectType::sbac);
+    const auto &sample =
+        *std::ranges::find(fixture.catalog.objects, "Sample", [](const auto &item) { return item.object.header.name; });
+
+    const auto partial =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {sample.key}, .referrer_keys = {program.key}, .cleanup_keys = {}});
+
+    ASSERT_TRUE(partial) << partial.error().message;
+    EXPECT_FALSE(partial->can_apply);
+    EXPECT_TRUE(partial->manifest.operations.empty());
+    const auto program_impact =
+        std::ranges::find(partial->impacts, program.key, &axk::ObjectDeletionImpact::object_key);
+    ASSERT_NE(program_impact, partial->impacts.end());
+    EXPECT_TRUE(program_impact->requested);
+    EXPECT_FALSE(program_impact->selected);
+    const auto bank_impact = std::ranges::find(partial->impacts, bank.key, &axk::ObjectDeletionImpact::object_key);
+    ASSERT_NE(bank_impact, partial->impacts.end());
+    EXPECT_EQ(bank_impact->prerequisite_keys, std::vector<std::string>{program.key});
+    EXPECT_EQ(std::ranges::find(partial->impacts, "Direct", &axk::ObjectDeletionImpact::object_name),
+              partial->impacts.end());
+
+    const auto complete = axk::inspect_object_deletion(
+        fixture.container, fixture.catalog, fixture.graph,
+        {.target_keys = {sample.key}, .referrer_keys = {program.key, bank.key}, .cleanup_keys = {}});
+
+    ASSERT_TRUE(complete) << complete.error().message;
+    EXPECT_TRUE(complete->can_apply);
+    ASSERT_EQ(complete->manifest.operations.size(), 3U);
+    EXPECT_TRUE(std::holds_alternative<axk::DeleteProgramOperation>(complete->manifest.operations[0].data));
+    EXPECT_TRUE(std::holds_alternative<axk::DeleteSampleBankOperation>(complete->manifest.operations[1].data));
+    EXPECT_TRUE(std::holds_alternative<axk::DeleteSampleOperation>(complete->manifest.operations[2].data));
 }
 
 TEST(ObjectDeletion, KeepsBlockedRootsOutOfAnOtherwiseApplicableBatch) {
@@ -309,8 +393,9 @@ TEST(ObjectDeletion, KeepsBlockedRootsOutOfAnOtherwiseApplicableBatch) {
     const auto &sample =
         *std::ranges::find(fixture.catalog.objects, "Sample", [](const auto &item) { return item.object.header.name; });
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = {program.key, sample.key}, .cleanup_keys = {}});
+    const auto inspected = axk::inspect_object_deletion(
+        fixture.container, fixture.catalog, fixture.graph,
+        {.target_keys = {program.key, sample.key}, .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
@@ -334,8 +419,9 @@ TEST(ObjectDeletion, AppliesAHeterogeneousBatchFromParentsToWaveData) {
             targets.push_back(item.key);
     }
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = std::move(targets), .cleanup_keys = {}});
+    const auto inspected =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = std::move(targets), .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
@@ -365,8 +451,9 @@ TEST(ObjectDeletion, RejectsDependenciesThatAreNotInTheTargetClosure) {
     const auto &sample = object(fixture, axk::ObjectType::sbnk);
     const auto &bank = object(fixture, axk::ObjectType::sbac);
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = {sample.key}, .cleanup_keys = {bank.key}});
+    const auto inspected =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {sample.key}, .referrer_keys = {}, .cleanup_keys = {bank.key}});
 
     ASSERT_FALSE(inspected);
     EXPECT_EQ(inspected.error().code, axk::ErrorCode::transaction_rejected);
@@ -377,10 +464,12 @@ TEST(ObjectDeletion, BlocksDirectDeletionOfReferencedSamplesAndWaveData) {
     const auto &sample = object(fixture, axk::ObjectType::sbnk);
     const auto &wave = object(fixture, axk::ObjectType::smpl);
 
-    const auto sample_inspection = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                                {.target_keys = {sample.key}, .cleanup_keys = {}});
-    const auto wave_inspection = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                              {.target_keys = {wave.key}, .cleanup_keys = {}});
+    const auto sample_inspection =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {sample.key}, .referrer_keys = {}, .cleanup_keys = {}});
+    const auto wave_inspection =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {wave.key}, .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(sample_inspection) << sample_inspection.error().message;
     EXPECT_FALSE(sample_inspection->can_apply);
@@ -392,8 +481,9 @@ TEST(ObjectDeletion, AllowsConfirmedUnreferencedWaveData) {
     const auto fixture = make_fixture(false, true);
     const auto &wave = object(fixture, axk::ObjectType::smpl);
 
-    const auto inspected = axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
-                                                        {.target_keys = {wave.key}, .cleanup_keys = {}});
+    const auto inspected =
+        axk::inspect_object_deletion(fixture.container, fixture.catalog, fixture.graph,
+                                     {.target_keys = {wave.key}, .referrer_keys = {}, .cleanup_keys = {}});
 
     ASSERT_TRUE(inspected) << inspected.error().message;
     EXPECT_TRUE(inspected->can_apply);
diff --git a/library/tests/package_program_slot_test.cpp b/library/tests/package_program_slot_test.cpp
index 9aa7665b..d22e33dd 100644
--- a/library/tests/package_program_slot_test.cpp
+++ b/library/tests/package_program_slot_test.cpp
@@ -116,6 +116,29 @@ TEST(PackageProgramSlots, FallsBackToTheLowestFragmentedFreeSlots) {
     EXPECT_EQ(placement.mappings[2].destination_slot, 5U);
 }
 
+TEST(PackageProgramSlots, KeepsProgramsGroupedInPackageOrder) {
+    axk::package_import_internal::ProgramSlotPlanningInput input;
+    const axk::package_import_internal::DestinationKey destination{0U, "Target"};
+    for (std::size_t package_index = 0U; package_index < 2U; ++package_index) {
+        for (std::uint8_t source_slot = 1U; source_slot <= 4U; ++source_slot) {
+            input.candidates.push_back({package_index, std::format("package-{}-program-{}", package_index, source_slot),
+                                        destination, source_slot, false});
+        }
+    }
+
+    const auto placements = axk::package_import_internal::plan_program_slot_placements(input);
+
+    ASSERT_EQ(placements.size(), 1U);
+    const auto &placement = placements.front();
+    ASSERT_EQ(placement.mappings.size(), 8U);
+    for (std::size_t index = 0U; index < placement.mappings.size(); ++index) {
+        const auto &mapping = placement.mappings[index];
+        EXPECT_EQ(mapping.package_index, index / 4U);
+        EXPECT_EQ(mapping.source_slot, index % 4U + 1U);
+        EXPECT_EQ(mapping.destination_slot, index + 1U);
+    }
+}
+
 TEST(PackageProgramSlots, ExcludesExactReuseFromCompactPlacement) {
     axk::package_import_internal::ProgramSlotPlanningInput input;
     const axk::package_import_internal::DestinationKey destination{0U, "Target"};
diff --git a/library/tests/version_test.cpp b/library/tests/version_test.cpp
index 6a93365b..ef234e13 100644
--- a/library/tests/version_test.cpp
+++ b/library/tests/version_test.cpp
@@ -18,7 +18,7 @@ TEST(Version, KeepsSemanticVersionSeparateFromSourceIdentity) {
     EXPECT_FALSE(source_identity.empty());
     EXPECT_EQ(package_basename, "axklib-" + std::string{source_identity});
     EXPECT_FALSE(std::string_view{build.git_sha_short}.empty());
-    EXPECT_EQ(source_identity.ends_with("-mod"), build.is_dirty);
+    EXPECT_EQ(source_identity.find("-dirty-") != std::string_view::npos, build.is_dirty);
     EXPECT_FALSE(std::string_view{build.is_tagged_release ? build.git_tag : build.git_branch}.empty());
     EXPECT_EQ(std::string_view{build.git_tag}.empty(), !build.is_tagged_release);
 }
diff --git a/tools/python/tests/test_release_tools.py b/tools/python/tests/test_release_tools.py
index 525982af..3cf89fc2 100644
--- a/tools/python/tests/test_release_tools.py
+++ b/tools/python/tests/test_release_tools.py
@@ -352,6 +352,23 @@ def test_version_metadata_rejects_inconsistent_values(tmp_path: Path) -> None:
         version_metadata.read(path)
 
 
+def test_version_metadata_accepts_version_branch_prerelease(tmp_path: Path) -> None:
+    path = tmp_path / "version.json"
+    write_metadata(path, metadata("1.2.3-pre", "1.2.3", is_prerelease=True))
+
+    assert version_metadata.read(path).semantic_version == "1.2.3-pre"
+
+
+@pytest.mark.parametrize("release_tag", ["1.2.3", "v1.2.3"])
+def test_version_metadata_accepts_optional_v_release_tag(
+    tmp_path: Path, release_tag: str
+) -> None:
+    path = tmp_path / "version.json"
+    write_metadata(path, metadata("1.2.3", "1.2.3", release_tag))
+
+    assert version_metadata.read(path).release_tag == release_tag
+
+
 def test_sbom_timestamp_and_namespace_are_reproducible(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -426,18 +443,19 @@ def test_release_metadata_uses_source_identity_and_debug_suffix(tmp_path: Path)
     assert debug.cli_artifact_stem.endswith("-windows-arm64-debug")
 
 
-def test_release_metadata_shortens_only_exact_project_tag() -> None:
-    version = metadata("1.2.3-rc.1+build.4", "1.2.3", "v1.2.3-rc.1+build.4", is_prerelease=True)
+@pytest.mark.parametrize("tag", ["1.2.3-rc.1+build.4", "v1.2.3-rc.1+build.4"])
+def test_release_metadata_shortens_only_exact_project_tag(tag: str) -> None:
+    version = metadata("1.2.3-rc.1+build.4", "1.2.3", tag, is_prerelease=True)
     artifact = release_metadata.artifact_metadata(
         "axklib-v1.2.3-rc.1-build.4-a1b2c3d",
         version,
         "tag",
-        "v1.2.3-rc.1+build.4",
+        tag,
         "macos-universal",
         "Release",
     )
     assert artifact.artifact_stem == "axklib-1.2.3-rc.1+build.4-macos-universal"
-    with pytest.raises(ValueError, match="release tag must be v1.2.3-rc.1[+]build.4"):
+    with pytest.raises(ValueError, match=rf"release tag must be {re.escape(tag)}"):
         release_metadata.artifact_metadata(
             "axklib-nightly-a1b2c3d",
             version,
@@ -448,7 +466,8 @@ def test_release_metadata_shortens_only_exact_project_tag() -> None:
         )
 
 
-def test_release_target_uses_preview_for_branches_and_preserves_tags() -> None:
+@pytest.mark.parametrize("tag_name", ["2.0.0", "v2.0.0"])
+def test_release_target_uses_preview_for_branches_and_preserves_tags(tag_name: str) -> None:
     branch = release_metadata.draft_release_target("branch", "features/packages", metadata())
     assert branch == release_metadata.DraftReleaseTarget(
         tag_name="features/packages-preview",
@@ -457,11 +476,11 @@ def test_release_target_uses_preview_for_branches_and_preserves_tags() -> None:
         verify_tag=False,
         prerelease=True,
     )
-    stable = metadata("2.0.0", "2.0.0", "v2.0.0")
-    tag = release_metadata.draft_release_target("tag", "v2.0.0", stable)
+    stable = metadata("2.0.0", "2.0.0", tag_name)
+    tag = release_metadata.draft_release_target("tag", tag_name, stable)
     assert tag == release_metadata.DraftReleaseTarget(
-        tag_name="v2.0.0",
-        title="v2.0.0",
+        tag_name=tag_name,
+        title=tag_name,
         cleanup_tag=False,
         verify_tag=True,
         prerelease=False,
@@ -842,6 +861,11 @@ def test_desktop_contract_and_rpm_inspection_are_cross_platform() -> None:
     root = Path(__file__).resolve().parents[3]
     attributes = (root / ".gitattributes").read_text(encoding="utf-8")
     prettier = json.loads((root / "apps/axkdeck/.prettierrc.json").read_text(encoding="utf-8"))
+    linux_bundle = json.loads(
+        (root / "apps/axkdeck/src-tauri/tauri.linux.conf.json").read_text(
+            encoding="utf-8"
+        )
+    )
     workflow = (root / ".github/workflows/native.yml").read_text(encoding="utf-8")
     native_platform = (root / ".github/workflows/native-platform.yml").read_text(
         encoding="utf-8"
@@ -850,7 +874,22 @@ def test_desktop_contract_and_rpm_inspection_are_cross_platform() -> None:
 
     assert "/apps/axkdeck/src/lib/generated/axklibApiV1.ts text eol=lf" in attributes
     assert prettier["endOfLine"] == "lf"
+    assert linux_bundle["bundle"]["linux"]["deb"]["depends"] == [
+        "libc++1-18",
+        "libc++abi1-18",
+        "libunwind-18",
+    ]
+    assert linux_bundle["bundle"]["linux"]["rpm"]["depends"] == [
+        "libcxx",
+        "llvm-libunwind",
+    ]
     assert "for command in curl wget file pkg-config patchelf rpm bsdtar dpkg-deb" in workflow_with_platform
+    assert 'dpkg-deb -f "$deb" Depends' in workflow_with_platform
+    assert 'rpm -qp --requires "$rpm"' in workflow_with_platform
+    assert "for dependency in libcxx llvm-libunwind; do" in workflow_with_platform
+    assert "for capability in libwebkit2gtk-4.1.so.0 libgtk-3.so.0; do" in workflow_with_platform
+    assert 'grep -F "${capability}()"' in workflow_with_platform
+    assert "webkit2gtk4.1 gtk3 libcxx llvm-libunwind" not in workflow_with_platform
     assert 'rpm -Kv "$rpm"' in workflow_with_platform
     assert 'bsdtar -xf "$GITHUB_WORKSPACE/$rpm" -C "$scan/rpm"' in workflow_with_platform
     assert "rpm2cpio" not in workflow_with_platform
diff --git a/tools/python/version_metadata.py b/tools/python/version_metadata.py
index 40859a5d..58629e41 100644
--- a/tools/python/version_metadata.py
+++ b/tools/python/version_metadata.py
@@ -60,10 +60,18 @@ def read(path: Path) -> VersionMetadata:
         raise ValueError("numeric version components do not match project_version")
     if value.is_release != bool(value.release_tag):
         raise ValueError("release_tag and is_release disagree")
-    if value.is_release and value.release_tag != f"v{value.semantic_version}":
+    if value.is_release and value.release_tag.removeprefix("v") != value.semantic_version:
         raise ValueError("release_tag does not match semantic_version")
-    if not value.is_release and value.semantic_version != "0.0.0":
-        raise ValueError("non-release version metadata must use 0.0.0")
     if value.is_prerelease != (match.group(4) is not None):
         raise ValueError("is_prerelease does not match semantic_version")
+    valid_development_version = (
+        value.semantic_version == "0.0.0" and not value.is_prerelease
+    ) or (
+        value.semantic_version == f"{value.project_version}-pre"
+        and value.is_prerelease
+    )
+    if not value.is_release and not valid_development_version:
+        raise ValueError(
+            "non-release version metadata must use 0.0.0 or a version-branch prerelease"
+        )
     return value