Expand --report-current to show partitions and all mounts (except pseudo-filesystems)

* choose ESP matching the primary data disk when multiple ESPs exist,
  falling back gracefully for single-disk layouts
* keep new helper to normalize device names and reuse the idempotent
  mount logic
* apply cargo fmt across the tree

README.md

@@ -20,7 +20,7 @@ Key modules
   - [src/partition/plan.rs](src/partition/plan.rs)
 - Filesystem planning/creation and mkfs integration:
   - [src/fs/plan.rs](src/fs/plan.rs)
-- Mount planning and application (skeleton):
+- Mount planning and application:
   - [src/mount/ops.rs](src/mount/ops.rs)
 
 Features at a glance

config/zosstorage.example.yaml

@@ -1,185 +0,0 @@
-# zosstorage example configuration (full surface)
-# Copy to /etc/zosstorage/config.yaml on the target system, or pass with:
-#   - CLI:   --config /path/to/your.yaml
-#   - Kernel cmdline: zosstorage.config=/path/to/your.yaml
-# Precedence (highest to lowest):
-#   kernel cmdline > CLI flags > CLI --config file > /etc/zosstorage/config.yaml > built-in defaults
-
-version: 1
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logging:
-  # one of: error, warn, info, debug
-  level: info
-  # when true, also logs to /run/zosstorage/zosstorage.log in initramfs
-  to_file: false
-
-# -----------------------------------------------------------------------------
-# Device selection rules
-# - include_patterns: device paths that are considered
-# - exclude_patterns: device paths to filter out
-# - allow_removable: future toggle for removable media (kept false by default)
-# - min_size_gib: ignore devices smaller than this size
-# -----------------------------------------------------------------------------
-device_selection:
-  include_patterns:
-    - "^/dev/sd\\w+$"
-    - "^/dev/nvme\\w+n\\d+$"
-    - "^/dev/vd\\w+$"
-  exclude_patterns:
-    - "^/dev/ram\\d+$"
-    - "^/dev/zram\\d+$"
-    - "^/dev/loop\\d+$"
-    - "^/dev/fd\\d+$"
-  allow_removable: false
-  min_size_gib: 10
-
-# -----------------------------------------------------------------------------
-# Desired topology (choose ONE)
-#   single             : Single eligible disk; btrfs on data
-#   dual_independent   : Two disks; independent btrfs on each
-#   ssd_hdd_bcachefs   : SSD + HDD; bcachefs with SSD as cache/promote and HDD backing
-#   btrfs_raid1        : Optional mirrored btrfs across two disks (only when explicitly requested)
-# -----------------------------------------------------------------------------
-topology:
-  mode: single
-  # mode: dual_independent
-  # mode: ssd_hdd_bcachefs
-  # mode: btrfs_raid1
-
-# -----------------------------------------------------------------------------
-# Partitioning (GPT only)
-# Reserved GPT names:
-#   - bios boot  : "zosboot" (tiny BIOS boot partition, non-FS)
-#   - ESP        : "zosboot" (FAT32)
-#   - Data       : "zosdata"
-#   - Cache      : "zoscache" (only for ssd_hdd_bcachefs)
-# Reserved filesystem labels:
-#   - ESP        : ZOSBOOT
-#   - Data (all filesystems including bcachefs): ZOSDATA
-# -----------------------------------------------------------------------------
-partitioning:
-  # 1 MiB alignment
-  alignment_mib: 1
-
-  # Abort if any target disk is not empty (required for safety)
-  require_empty_disks: true
-
-  bios_boot:
-    enabled: true
-    size_mib: 1
-    gpt_name: zosboot
-
-  esp:
-    size_mib: 512
-    label: ZOSBOOT
-    gpt_name: zosboot
-
-  data:
-    gpt_name: zosdata
-
-  # Only used in ssd_hdd_bcachefs
-  cache:
-    gpt_name: zoscache
-
-# -----------------------------------------------------------------------------
-# Filesystem options and tuning
-# All data filesystems (btrfs or bcachefs) use label ZOSDATA
-# ESP uses label ZOSBOOT
-# -----------------------------------------------------------------------------
-filesystem:
-  btrfs:
-    # Reserved; must be "ZOSDATA"
-    label: ZOSDATA
-    # e.g., "zstd:3", "zstd:5"
-    compression: zstd:3
-    # "none" | "raid1" (raid1 typically when topology.mode == btrfs_raid1)
-    raid_profile: none
-
-  bcachefs:
-    # Reserved; must be "ZOSDATA"
-    label: ZOSDATA
-    # "promote" (default) or "writeback" if supported by environment
-    cache_mode: promote
-    # Compression algorithm, e.g., "zstd"
-    compression: zstd
-    # Checksum algorithm, e.g., "crc32c"
-    checksum: crc32c
-
-  vfat:
-    # Reserved; must be "ZOSBOOT"
-    label: ZOSBOOT
-
-# -----------------------------------------------------------------------------
-# Mount scheme and optional fstab
-# Default behavior mounts data filesystems under /var/cache/<UUID>
-# -----------------------------------------------------------------------------
-mount:
-  # Base directory for mounts
-  base_dir: /var/cache
-  # Scheme: per_uuid | custom (custom reserved for future)
-  scheme: per_uuid
-  # When true, zosstorage will generate /etc/fstab entries in deterministic order
-  fstab_enabled: false
-
-# -----------------------------------------------------------------------------
-# Report output
-# JSON report is written after successful provisioning
-# -----------------------------------------------------------------------------
-report:
-  path: /run/zosstorage/state.json
-
-# -----------------------------------------------------------------------------
-# Examples for different topologies (uncomment and set topology.mode accordingly)
-# -----------------------------------------------------------------------------
-
-# Example: single disk (uses btrfs on data)
-# topology:
-#   mode: single
-# filesystem:
-#   btrfs:
-#     label: ZOSDATA
-#     compression: zstd:3
-#     raid_profile: none
-
-# Example: dual independent btrfs (two disks)
-# topology:
-#   mode: dual_independent
-# filesystem:
-#   btrfs:
-#     label: ZOSDATA
-#     compression: zstd:5
-#     raid_profile: none
-
-# Example: SSD + HDD with bcachefs
-# topology:
-#   mode: ssd_hdd_bcachefs
-# partitioning:
-#   cache:
-#     gpt_name: zoscache
-# filesystem:
-#   bcachefs:
-#     label: ZOSDATA
-#     cache_mode: promote
-#     compression: zstd
-#     checksum: crc32c
-
-# Example: btrfs RAID1 (two disks)
-# topology:
-#   mode: btrfs_raid1
-# filesystem:
-#   btrfs:
-#     label: ZOSDATA
-#     compression: zstd:3
-#     raid_profile: raid1
-
-# -----------------------------------------------------------------------------
-# Notes:
-# - Never modify devices outside include_patterns or inside exclude_patterns.
-# - Idempotency: if expected GPT names and filesystem labels are already present,
-#   zosstorage exits success without making changes.
-# - --force flag is reserved and not implemented; will return an "unimplemented" error.
-# - Kernel cmdline data: URLs for zosstorage.config= are currently unimplemented.
-# -----------------------------------------------------------------------------

docs/API.md

@@ -75,7 +75,7 @@ Configuration types
 - [struct Config](../src/types.rs:1)
   - The validated configuration used by the orchestrator, containing logging, device selection rules, topology, partitioning, filesystem options, mount scheme, and report path.
 - [enum Topology](../src/types.rs:1)
-  - Values: btrfs_single, bcachefs_single, dual_independent, bcachefs2_copy, ssd_hdd_bcachefs, btrfs_raid1 (opt-in).
+  - Values: btrfs_single, bcachefs_single, dual_independent, bcachefs-2copy, ssd_hdd_bcachefs, btrfs_raid1 (opt-in).
 - [struct DeviceSelection](../src/types.rs:1)
   - Include and exclude regex patterns, minimum size, removable policy.
 - [struct Partitioning](../src/types.rs:1)
@@ -201,7 +201,7 @@ Behavioral notes and contracts
   - btrfs_single: one data filesystem (btrfs) on the sole disk.
   - bcachefs_single: one data filesystem (bcachefs) on the sole disk.
   - dual_independent: independent btrfs filesystems on each eligible disk (one or more).
-  - bcachefs2_copy: multi-device bcachefs across two or more data partitions with `--replicas=2` (data and metadata).
+  - bcachefs-2copy: multi-device bcachefs across two or more data partitions with `--replicas=2` (data and metadata).
   - ssd_hdd_bcachefs: bcachefs spanning SSD (cache/promote) and HDD (backing), labeled ZOSDATA.
   - btrfs_raid1: only when explicitly requested; otherwise default to independent btrfs.
 - UEFI vs BIOS: when running under UEFI (`/sys/firmware/efi` present), the BIOS boot partition is suppressed.

docs/SCHEMA.md

@@ -32,7 +32,7 @@ device_selection:
   allow_removable: false     # future option; default false
   min_size_gib: 10           # ignore devices smaller than this (default 10)
 topology:                    # desired overall layout; see values below
-  mode: btrfs_single         # btrfs_single | bcachefs_single | dual_independent | bcachefs2_copy | ssd_hdd_bcachefs | btrfs_raid1
+  mode: btrfs_single         # btrfs_single | bcachefs_single | dual_independent | bcachefs-2copy | ssd_hdd_bcachefs | btrfs_raid1
 partitioning:
   alignment_mib: 1           # GPT alignment in MiB
   require_empty_disks: true  # abort if any partition or FS signatures exist
@@ -73,7 +73,7 @@ Topology modes
 - btrfs_single: One eligible disk. Create BIOS boot (if enabled), ESP 512 MiB, remainder as data. Create a btrfs filesystem labeled ZOSDATA on the data partition.
 - bcachefs_single: One eligible disk. Create BIOS boot (if enabled), ESP 512 MiB, remainder as data. Create a bcachefs filesystem labeled ZOSDATA on the data partition.
 - dual_independent: One or more eligible disks. On each disk, create BIOS boot (if enabled) + ESP + data. Create an independent btrfs filesystem labeled ZOSDATA on each data partition. No RAID by default.
-- bcachefs2_copy: Two or more eligible disks (minimum 2). Create data partitions and then a single multi-device bcachefs labeled ZOSDATA spanning those data partitions. The mkfs step uses `--replicas=2` (data and metadata).
+- bcachefs-2copy: Two or more eligible disks (minimum 2). Create data partitions and then a single multi-device bcachefs labeled ZOSDATA spanning those data partitions. The mkfs step uses `--replicas=2` (data and metadata).
 - ssd_hdd_bcachefs: One SSD/NVMe and one HDD. Create BIOS boot (if enabled) + ESP on both as required. Create cache (on SSD) and data/backing (on HDD) partitions named zoscache and zosdata respectively. Create a bcachefs labeled ZOSDATA across SSD(HDD) per policy (SSD cache/promote; HDD backing).
 - btrfs_raid1: Optional mode if explicitly requested. Create mirrored btrfs across two disks for the data role with raid1 profile. Not enabled by default.
 

docs/SPECS.md

@@ -184,7 +184,7 @@ Per-topology specifics
 - btrfs_single: All roles on the single disk; data formatted as btrfs.
 - bcachefs_single: All roles on the single disk; data formatted as bcachefs.
 - dual_independent: On each eligible disk (one or more), create BIOS boot (if applicable), ESP, and data.
-- bcachefs_2copy: Create data partitions on two or more disks; later formatted as one multi-device bcachefs spanning all data partitions.
+- bcachefs-2copy: Create data partitions on two or more disks; later formatted as one multi-device bcachefs spanning all data partitions.
 - ssd_hdd_bcachefs: SSD gets BIOS boot + ESP + zoscache; HDD gets BIOS boot + ESP + zosdata; combined later into one bcachefs.
 - btrfs_raid1: Two disks minimum; data partitions mirrored via btrfs RAID1.
 
@@ -203,12 +203,12 @@ Application
 Kinds
 - Vfat for ESP, label ZOSBOOT.
 - Btrfs for data in btrfs_single, dual_independent, and btrfs_raid1 (with RAID1 profile).
-- Bcachefs for data in bcachefs_single, ssd_hdd_bcachefs (SSD cache + HDD backing), and bcachefs_2copy (multi-device).
+- Bcachefs for data in bcachefs_single, ssd_hdd_bcachefs (SSD cache + HDD backing), and bcachefs-2copy (multi-device).
 - All data filesystems use label ZOSDATA.
 
 Defaults
 - btrfs: compression zstd:3, raid_profile none unless explicitly set; for btrfs_raid1 use -m raid1 -d raid1.
-- bcachefs: cache_mode promote, compression zstd, checksum crc32c; for bcachefs_2copy use `--replicas=2` (data and metadata).
+- bcachefs: cache_mode promote, compression zstd, checksum crc32c; for bcachefs-2copy use `--replicas=2` (data and metadata).
 - vfat: ESP label ZOSBOOT.
 
 Planning and execution
@@ -267,7 +267,7 @@ Kernel cmdline
 Help text sections
 - NAME, SYNOPSIS, DESCRIPTION
 - CONFIG PRECEDENCE
-- TOPOLOGIES: btrfs_single, bcachefs_single, dual_independent, bcachefs_2copy, ssd_hdd_bcachefs, btrfs_raid1
+- TOPOLOGIES: btrfs_single, bcachefs_single, dual_independent, bcachefs-2copy, ssd_hdd_bcachefs, btrfs_raid1
 - SAFETY AND IDEMPOTENCY
 - REPORTS
 - EXIT CODES: 0 success or already_provisioned, non-zero on error
@@ -280,7 +280,7 @@ Scenarios to scaffold in [tests/](tests/)
 - Single disk 40 GiB virtio: validates btrfs_single topology end-to-end smoke.
 - Dual NVMe 40 GiB each: validates dual_independent topology (independent btrfs per disk).
 - SSD NVMe + HDD virtio: validates ssd_hdd_bcachefs topology (bcachefs with SSD cache/promote, HDD backing).
-- Three disks: validates bcachefs_2copy across data partitions using `--replicas=2`.
+- Three disks: validates bcachefs-2copy across data partitions using `--replicas=2`.
 - Negative: no eligible disks, or non-empty disk should abort.
 
 Test strategy

docs/adr/0002-defaults-only-no-external-config.md

@@ -26,17 +26,17 @@ Decision
     - Allowed cmdline overrides: btrfs_single, bcachefs_single
   - 2 eligible disks:
     - Default: dual_independent
-    - Allowed cmdline overrides: dual_independent, ssd_hdd_bcachefs, btrfs_raid1, bcachefs_2copy
+    - Allowed cmdline overrides: dual_independent, ssd_hdd_bcachefs, btrfs_raid1, bcachefs-2copy
   - >2 eligible disks:
     - Default: btrfs_raid1
-    - Allowed cmdline overrides: btrfs_raid1, bcachefs_2copy
-- Accept both snake_case and hyphenated forms for VALUE; normalize to [enum Topology](../../src/types.rs:1):
+    - Allowed cmdline overrides: btrfs_raid1, bcachefs-2copy
+- Accept both snake_case and hyphenated forms for VALUE; canonical for two-copy bcachefs is bcachefs-2copy; normalize to [enum Topology](../../src/types.rs:1):
   - btrfs_single | btrfs-single
   - bcachefs_single | bcachefs-single
   - dual_independent | dual-independent
   - ssd_hdd_bcachefs | ssd-hdd-bcachefs
   - btrfs_raid1 | btrfs-raid1
-  - bcachefs_2copy | bcachefs-2copy
+  - bcachefs-2copy
 - Kernel cmdline parsing beyond topology is deferred; future extensions for VM workflows may be proposed separately.
 
 Rationale
@@ -67,7 +67,7 @@ Defaults (authoritative)
 - Filesystems:
   - ESP: vfat labeled ZOSBOOT
   - Data: label ZOSDATA
-  - Backend per topology (btrfs for btrfs_*; bcachefs for ssd_hdd_bcachefs and bcachefs_2copy)
+  - Backend per topology (btrfs for btrfs_*; bcachefs for ssd_hdd_bcachefs and bcachefs-2copy)
 - Mount scheme:
   - Root-mount all data filesystems under /var/mounts/{UUID}; final subvolume/subdir mounts from the primary data FS to /var/cache/{system,etc,modules,vm-meta}; fstab remains optional.
 - Idempotency:

src/config/loader.rs

@@ -42,8 +42,8 @@
 
 use std::fs;
 
-use crate::{cli::Cli, Error, Result};
 use crate::types::*;
+use crate::{Error, Result, cli::Cli};
 use serde_json::{Map, Value, json};
 use tracing::warn;
 
@@ -77,17 +77,17 @@ pub fn load_and_merge(cli: &Cli) -> Result<Config> {
     let cli_overlay = cli_overlay_value(cli);
     merge_value(&mut merged, cli_overlay);
 
-   // 5) Kernel cmdline topology override only when CLI did not provide topology
-   if cli.topology.is_none() {
-       if let Some(topo) = kernel_cmdline_topology() {
-           merge_value(&mut merged, json!({"topology": topo.to_string()}));
-       }
-   }
+    // 5) Kernel cmdline topology override only when CLI did not provide topology
+    if cli.topology.is_none() {
+        if let Some(topo) = kernel_cmdline_topology() {
+            merge_value(&mut merged, json!({"topology": topo.to_string()}));
+        }
+    }
 
-   // Finalize
-   let cfg: Config = serde_json::from_value(merged).map_err(|e| Error::Other(e.into()))?;
-   validate(&cfg)?;
-   Ok(cfg)
+    // Finalize
+    let cfg: Config = serde_json::from_value(merged).map_err(|e| Error::Other(e.into()))?;
+    validate(&cfg)?;
+    Ok(cfg)
 }
 
 /// Validate semantic correctness of the configuration.
@@ -128,43 +128,50 @@ pub fn validate(cfg: &Config) -> Result<()> {
     }
 
     // Reserved GPT names
-    if cfg.partitioning.esp.gpt_name != "zosboot" {
-        return Err(Error::Validation(
-            "partitioning.esp.gpt_name must be 'zosboot'".into(),
-        ));
+    if cfg.partitioning.esp.gpt_name != GPT_NAME_ZOSBOOT {
+        return Err(Error::Validation(format!(
+            "partitioning.esp.gpt_name must be '{}'",
+            GPT_NAME_ZOSBOOT
+        )));
     }
-    if cfg.partitioning.data.gpt_name != "zosdata" {
-        return Err(Error::Validation(
-            "partitioning.data.gpt_name must be 'zosdata'".into(),
-        ));
+    if cfg.partitioning.data.gpt_name != GPT_NAME_ZOSDATA {
+        return Err(Error::Validation(format!(
+            "partitioning.data.gpt_name must be '{}'",
+            GPT_NAME_ZOSDATA
+        )));
     }
-    if cfg.partitioning.cache.gpt_name != "zoscache" {
-        return Err(Error::Validation(
-            "partitioning.cache.gpt_name must be 'zoscache'".into(),
-        ));
+    if cfg.partitioning.cache.gpt_name != GPT_NAME_ZOSCACHE {
+        return Err(Error::Validation(format!(
+            "partitioning.cache.gpt_name must be '{}'",
+            GPT_NAME_ZOSCACHE
+        )));
     }
     // BIOS boot name is also 'zosboot' per current assumption
-    if cfg.partitioning.bios_boot.gpt_name != "zosboot" {
-        return Err(Error::Validation(
-            "partitioning.bios_boot.gpt_name must be 'zosboot'".into(),
-        ));
+    if cfg.partitioning.bios_boot.gpt_name != GPT_NAME_ZOSBOOT {
+        return Err(Error::Validation(format!(
+            "partitioning.bios_boot.gpt_name must be '{}'",
+            GPT_NAME_ZOSBOOT
+        )));
     }
 
     // Reserved filesystem labels
-    if cfg.filesystem.vfat.label != "ZOSBOOT" {
-        return Err(Error::Validation(
-            "filesystem.vfat.label must be 'ZOSBOOT'".into(),
-        ));
+    if cfg.filesystem.vfat.label != LABEL_ZOSBOOT {
+        return Err(Error::Validation(format!(
+            "filesystem.vfat.label must be '{}'",
+            LABEL_ZOSBOOT
+        )));
     }
-    if cfg.filesystem.btrfs.label != "ZOSDATA" {
-        return Err(Error::Validation(
-            "filesystem.btrfs.label must be 'ZOSDATA'".into(),
-        ));
+    if cfg.filesystem.btrfs.label != LABEL_ZOSDATA {
+        return Err(Error::Validation(format!(
+            "filesystem.btrfs.label must be '{}'",
+            LABEL_ZOSDATA
+        )));
     }
-    if cfg.filesystem.bcachefs.label != "ZOSDATA" {
-        return Err(Error::Validation(
-            "filesystem.bcachefs.label must be 'ZOSDATA'".into(),
-        ));
+    if cfg.filesystem.bcachefs.label != LABEL_ZOSDATA {
+        return Err(Error::Validation(format!(
+            "filesystem.bcachefs.label must be '{}'",
+            LABEL_ZOSDATA
+        )));
     }
 
     // Mount scheme
@@ -181,7 +188,9 @@ pub fn validate(cfg: &Config) -> Result<()> {
         Topology::Bcachefs2Copy => {}
         Topology::BtrfsRaid1 => {
             // No enforced requirement here beyond presence of two disks at runtime.
-            if cfg.filesystem.btrfs.raid_profile != "raid1" && cfg.filesystem.btrfs.raid_profile != "none" {
+            if cfg.filesystem.btrfs.raid_profile != "raid1"
+                && cfg.filesystem.btrfs.raid_profile != "none"
+            {
                 return Err(Error::Validation(
                     "filesystem.btrfs.raid_profile must be 'none' or 'raid1'".into(),
                 ));
@@ -203,7 +212,6 @@ fn to_value<T: serde::Serialize>(t: T) -> Result<Value> {
     serde_json::to_value(t).map_err(|e| Error::Other(e.into()))
 }
 
-
 /// Merge b into a in-place:
 /// - Objects are merged key-by-key (recursively)
 /// - Arrays and scalars replace
@@ -270,7 +278,9 @@ pub fn kernel_cmdline_topology() -> Option<Topology> {
             val_opt = Some(v);
         }
         if let Some(mut val) = val_opt {
-            if (val.starts_with('"') && val.ends_with('"')) || (val.starts_with('\'') && val.ends_with('\'')) {
+            if (val.starts_with('"') && val.ends_with('"'))
+                || (val.starts_with('\'') && val.ends_with('\''))
+            {
                 val = &val[1..val.len() - 1];
             }
             let val_norm = val.trim();
@@ -282,7 +292,8 @@ pub fn kernel_cmdline_topology() -> Option<Topology> {
     None
 }
 
-/// Helper to parse known topology tokens in kebab- or snake-case.
+//// Helper to parse known topology tokens (canonical names only).
+//// Note: underscores are normalized to hyphens prior to matching.
 fn parse_topology_token(s: &str) -> Option<Topology> {
     let k = s.trim().to_ascii_lowercase().replace('_', "-");
     match k.as_str() {
@@ -290,7 +301,8 @@ fn parse_topology_token(s: &str) -> Option<Topology> {
         "bcachefs-single" => Some(Topology::BcachefsSingle),
         "dual-independent" => Some(Topology::DualIndependent),
         "ssd-hdd-bcachefs" => Some(Topology::SsdHddBcachefs),
-        "bcachefs2-copy" | "bcachefs-2copy" | "bcachefs-2-copy" => Some(Topology::Bcachefs2Copy),
+        // Canonical single notation for two-copy bcachefs topology
+        "bcachefs-2copy" => Some(Topology::Bcachefs2Copy),
         "btrfs-raid1" => Some(Topology::BtrfsRaid1),
         _ => None,
     }

src/config/mod.rs

@@ -11,5 +11,5 @@
 
 pub mod loader;
 
-pub use loader::{load_and_merge, validate};
 pub use crate::types::*;
+pub use loader::{load_and_merge, validate};

src/device/discovery.rs

@@ -186,7 +186,10 @@ pub fn discover(filter: &DeviceFilter) -> Result<Vec<Disk>> {
     discover_with_provider(&provider, filter)
 }
 
-fn discover_with_provider<P: DeviceProvider>(provider: &P, filter: &DeviceFilter) -> Result<Vec<Disk>> {
+fn discover_with_provider<P: DeviceProvider>(
+    provider: &P,
+    filter: &DeviceFilter,
+) -> Result<Vec<Disk>> {
     let mut candidates = provider.list_block_devices()?;
     // Probe properties if provider needs to enrich
     for d in &mut candidates {
@@ -210,10 +213,15 @@ fn discover_with_provider<P: DeviceProvider>(provider: &P, filter: &DeviceFilter
         .collect();
 
     if filtered.is_empty() {
-        return Err(Error::Device("no eligible disks found after applying filters".to_string()));
+        return Err(Error::Device(
+            "no eligible disks found after applying filters".to_string(),
+        ));
     }
 
-    debug!("eligible disks: {:?}", filtered.iter().map(|d| &d.path).collect::<Vec<_>>());
+    debug!(
+        "eligible disks: {:?}",
+        filtered.iter().map(|d| &d.path).collect::<Vec<_>>()
+    );
     Ok(filtered)
 }
 
@@ -259,9 +267,10 @@ fn read_disk_size_bytes(name: &str) -> Result<u64> {
     let p = sys_block_path(name).join("size");
     let sectors = fs::read_to_string(&p)
         .map_err(|e| Error::Device(format!("read {} failed: {}", p.display(), e)))?;
-    let sectors: u64 = sectors.trim().parse().map_err(|e| {
-        Error::Device(format!("parse sectors for {} failed: {}", name, e))
-    })?;
+    let sectors: u64 = sectors
+        .trim()
+        .parse()
+        .map_err(|e| Error::Device(format!("parse sectors for {} failed: {}", name, e)))?;
     Ok(sectors.saturating_mul(512))
 }
 
@@ -287,11 +296,7 @@ fn read_optional_string(p: PathBuf) -> Option<String> {
             while s.ends_with('\n') || s.ends_with('\r') {
                 s.pop();
             }
-            if s.is_empty() {
-                None
-            } else {
-                Some(s)
-            }
+            if s.is_empty() { None } else { Some(s) }
         }
         Err(_) => None,
     }
@@ -324,9 +329,27 @@ mod tests {
     fn filter_by_size_and_include_exclude() {
         let provider = MockProvider {
             disks: vec![
-                Disk { path: "/dev/sda".into(), size_bytes: 500 * 1024 * 1024 * 1024, rotational: true, model: None, serial: None }, // 500 GiB
-                Disk { path: "/dev/nvme0n1".into(), size_bytes: 128 * 1024 * 1024 * 1024, rotational: false, model: None, serial: None }, // 128 GiB
-                Disk { path: "/dev/loop0".into(), size_bytes: 8 * 1024 * 1024 * 1024, rotational: false, model: None, serial: None }, // 8 GiB pseudo (but mock provider supplies it)
+                Disk {
+                    path: "/dev/sda".into(),
+                    size_bytes: 500 * 1024 * 1024 * 1024,
+                    rotational: true,
+                    model: None,
+                    serial: None,
+                }, // 500 GiB
+                Disk {
+                    path: "/dev/nvme0n1".into(),
+                    size_bytes: 128 * 1024 * 1024 * 1024,
+                    rotational: false,
+                    model: None,
+                    serial: None,
+                }, // 128 GiB
+                Disk {
+                    path: "/dev/loop0".into(),
+                    size_bytes: 8 * 1024 * 1024 * 1024,
+                    rotational: false,
+                    model: None,
+                    serial: None,
+                }, // 8 GiB pseudo (but mock provider supplies it)
             ],
         };
 
@@ -346,7 +369,13 @@ mod tests {
     fn no_match_returns_error() {
         let provider = MockProvider {
             disks: vec![
-                Disk { path: "/dev/sdb".into(), size_bytes: 50 * 1024 * 1024 * 1024, rotational: true, model: None, serial: None }, // 50 GiB
+                Disk {
+                    path: "/dev/sdb".into(),
+                    size_bytes: 50 * 1024 * 1024 * 1024,
+                    rotational: true,
+                    model: None,
+                    serial: None,
+                }, // 50 GiB
             ],
         };
 

src/fs/plan.rs

@@ -18,21 +18,21 @@
 // ext: dry-run mode to emit mkfs commands without executing (future).
 // REGION: EXTENSION_POINTS-END
 //
- // REGION: SAFETY
- // safety: must not run mkfs on non-empty or unexpected partitions; assume prior validation enforced.
- // safety: ensure labels follow reserved semantics (ZOSBOOT for ESP, ZOSDATA for all data FS).
- // safety: mkfs.btrfs uses -f in apply path immediately after partitioning to handle leftover signatures.
- // REGION: SAFETY-END
+// REGION: SAFETY
+// safety: must not run mkfs on non-empty or unexpected partitions; assume prior validation enforced.
+// safety: ensure labels follow reserved semantics (ZOSBOOT for ESP, ZOSDATA for all data FS).
+// safety: mkfs.btrfs uses -f in apply path immediately after partitioning to handle leftover signatures.
+// REGION: SAFETY-END
 //
 // REGION: ERROR_MAPPING
 // errmap: external mkfs/blkid failures -> crate::Error::Tool with captured stderr.
 // errmap: planning mismatches -> crate::Error::Filesystem with context.
 // REGION: ERROR_MAPPING-END
 //
- // REGION: TODO
- // todo: bcachefs tuning flags mapping from config (compression/checksum/cache_mode) deferred
- // todo: add UUID consistency checks across multi-device filesystems
- // REGION: TODO-END
+// REGION: TODO
+// todo: bcachefs tuning flags mapping from config (compression/checksum/cache_mode) deferred
+// todo: add UUID consistency checks across multi-device filesystems
+// REGION: TODO-END
 //! Filesystem planning and creation for zosstorage.
 //!
 //! Maps partition results to concrete filesystems (vfat, btrfs, bcachefs)
@@ -42,14 +42,13 @@
 //! [fn make_filesystems](plan.rs:1).
 
 use crate::{
-    Result,
+    Error, Result,
+    partition::{PartRole, PartitionResult},
     types::{Config, Topology},
-    partition::{PartitionResult, PartRole},
     util::{run_cmd, run_cmd_capture, which_tool},
-    Error,
 };
-use tracing::{debug, warn};
 use std::fs;
+use tracing::{debug, warn};
 
 /// Filesystem kinds supported by zosstorage.
 #[derive(Debug, Clone, Copy)]
@@ -97,17 +96,14 @@ pub struct FsResult {
     pub label: String,
 }
 
-    /// Determine which partitions get which filesystem based on topology.
-    ///
-    /// Rules:
-    /// - ESP partitions => Vfat with label from cfg.filesystem.vfat.label (reserved "ZOSBOOT")
-    /// - Data partitions => Btrfs with label cfg.filesystem.btrfs.label ("ZOSDATA"), unless topology SsdHddBcachefs
-    /// - SsdHddBcachefs => pair one Cache partition (SSD) with one Data partition (HDD) into one Bcachefs FsSpec with devices [cache, data] and label cfg.filesystem.bcachefs.label ("ZOSDATA")
-    /// - DualIndependent/BtrfsRaid1 => map each Data partition to its own Btrfs FsSpec (raid profile concerns are handled later during mkfs)
-pub fn plan_filesystems(
-    parts: &[PartitionResult],
-    cfg: &Config,
-) -> Result<FsPlan> {
+/// Determine which partitions get which filesystem based on topology.
+///
+/// Rules:
+/// - ESP partitions => Vfat with label from cfg.filesystem.vfat.label (reserved "ZOSBOOT")
+/// - Data partitions => Btrfs with label cfg.filesystem.btrfs.label ("ZOSDATA"), unless topology SsdHddBcachefs
+/// - SsdHddBcachefs => pair one Cache partition (SSD) with one Data partition (HDD) into one Bcachefs FsSpec with devices [cache, data] and label cfg.filesystem.bcachefs.label ("ZOSDATA")
+/// - DualIndependent/BtrfsRaid1 => map each Data partition to its own Btrfs FsSpec (raid profile concerns are handled later during mkfs)
+pub fn plan_filesystems(parts: &[PartitionResult], cfg: &Config) -> Result<FsPlan> {
     let mut specs: Vec<FsSpec> = Vec::new();
 
     // Always map ESP partitions
@@ -122,10 +118,22 @@ pub fn plan_filesystems(
     match cfg.topology {
         Topology::SsdHddBcachefs => {
             // Expect exactly one cache (SSD) and at least one data (HDD). Use the first data for pairing.
-            let cache = parts.iter().find(|p| matches!(p.role, PartRole::Cache))
-                .ok_or_else(|| Error::Filesystem("expected a Cache partition for SsdHddBcachefs topology".to_string()))?;
-            let data = parts.iter().find(|p| matches!(p.role, PartRole::Data))
-                .ok_or_else(|| Error::Filesystem("expected a Data partition for SsdHddBcachefs topology".to_string()))?;
+            let cache = parts
+                .iter()
+                .find(|p| matches!(p.role, PartRole::Cache))
+                .ok_or_else(|| {
+                    Error::Filesystem(
+                        "expected a Cache partition for SsdHddBcachefs topology".to_string(),
+                    )
+                })?;
+            let data = parts
+                .iter()
+                .find(|p| matches!(p.role, PartRole::Data))
+                .ok_or_else(|| {
+                    Error::Filesystem(
+                        "expected a Data partition for SsdHddBcachefs topology".to_string(),
+                    )
+                })?;
 
             specs.push(FsSpec {
                 kind: FsKind::Bcachefs,
@@ -173,8 +181,14 @@ pub fn plan_filesystems(
         }
         Topology::BcachefsSingle => {
             // Single-device bcachefs on the sole Data partition.
-            let data = parts.iter().find(|p| matches!(p.role, PartRole::Data))
-                .ok_or_else(|| Error::Filesystem("expected a Data partition for BcachefsSingle topology".to_string()))?;
+            let data = parts
+                .iter()
+                .find(|p| matches!(p.role, PartRole::Data))
+                .ok_or_else(|| {
+                    Error::Filesystem(
+                        "expected a Data partition for BcachefsSingle topology".to_string(),
+                    )
+                })?;
             specs.push(FsSpec {
                 kind: FsKind::Bcachefs,
                 devices: vec![data.device_path.clone()],
@@ -194,7 +208,9 @@ pub fn plan_filesystems(
     }
 
     if specs.is_empty() {
-        return Err(Error::Filesystem("no filesystems to create from provided partitions".to_string()));
+        return Err(Error::Filesystem(
+            "no filesystems to create from provided partitions".to_string(),
+        ));
     }
 
     Ok(FsPlan { specs })
@@ -215,7 +231,9 @@ pub fn make_filesystems(plan: &FsPlan, cfg: &Config) -> Result<Vec<FsResult>> {
     let blkid_tool = which_tool("blkid")?;
 
     if blkid_tool.is_none() {
-        return Err(Error::Filesystem("blkid not found in PATH; cannot capture filesystem UUIDs".into()));
+        return Err(Error::Filesystem(
+            "blkid not found in PATH; cannot capture filesystem UUIDs".into(),
+        ));
     }
     let blkid = blkid_tool.unwrap();
 
@@ -248,7 +266,9 @@ pub fn make_filesystems(plan: &FsPlan, cfg: &Config) -> Result<Vec<FsResult>> {
                     return Err(Error::Filesystem("mkfs.btrfs not found in PATH".into()));
                 };
                 if spec.devices.is_empty() {
-                    return Err(Error::Filesystem("btrfs requires at least one device".into()));
+                    return Err(Error::Filesystem(
+                        "btrfs requires at least one device".into(),
+                    ));
                 }
                 // mkfs.btrfs -L LABEL [ -m raid1 -d raid1 (when multi-device/raid1) ] dev1 [dev2 ...]
                 let mut args: Vec<String> = vec![mkfs.clone(), "-L".into(), spec.label.clone()];
@@ -288,11 +308,18 @@ pub fn make_filesystems(plan: &FsPlan, cfg: &Config) -> Result<Vec<FsResult>> {
                     return Err(Error::Filesystem("bcachefs not found in PATH".into()));
                 };
                 if spec.devices.is_empty() {
-                    return Err(Error::Filesystem("bcachefs requires at least one device".into()));
+                    return Err(Error::Filesystem(
+                        "bcachefs requires at least one device".into(),
+                    ));
                 }
                 // bcachefs format --label LABEL [--replicas=2] dev1 [dev2 ...]
                 // Apply replicas policy for Bcachefs2Copy topology (data+metadata replicas = 2)
-                let mut args: Vec<String> = vec![mkfs.clone(), "format".into(), "--label".into(), spec.label.clone()];
+                let mut args: Vec<String> = vec![
+                    mkfs.clone(),
+                    "format".into(),
+                    "--label".into(),
+                    spec.label.clone(),
+                ];
                 if matches!(cfg.topology, Topology::Bcachefs2Copy) {
                     args.push("--replicas=2".into());
                 }
@@ -318,29 +345,32 @@ pub fn make_filesystems(plan: &FsPlan, cfg: &Config) -> Result<Vec<FsResult>> {
 }
 
 fn capture_uuid(blkid: &str, dev: &str) -> Result<String> {
-   // blkid -o export /dev/...
-   let out = run_cmd_capture(&[blkid, "-o", "export", dev])?;
-   let map = parse_blkid_export(&out.stdout);
-   // Prefer ID_FS_UUID if present, fall back to UUID
-   if let Some(u) = map.get("ID_FS_UUID") {
-       return Ok(u.clone());
-   }
-   if let Some(u) = map.get("UUID") {
-       return Ok(u.clone());
-   }
-   warn!("blkid did not report UUID for {}", dev);
-   Err(Error::Filesystem(format!("missing UUID in blkid output for {}", dev)))
+    // blkid -o export /dev/...
+    let out = run_cmd_capture(&[blkid, "-o", "export", dev])?;
+    let map = parse_blkid_export(&out.stdout);
+    // Prefer ID_FS_UUID if present, fall back to UUID
+    if let Some(u) = map.get("ID_FS_UUID") {
+        return Ok(u.clone());
+    }
+    if let Some(u) = map.get("UUID") {
+        return Ok(u.clone());
+    }
+    warn!("blkid did not report UUID for {}", dev);
+    Err(Error::Filesystem(format!(
+        "missing UUID in blkid output for {}",
+        dev
+    )))
 }
 
 /// Minimal parser for blkid -o export KEY=VAL lines.
 fn parse_blkid_export(s: &str) -> std::collections::HashMap<String, String> {
-   let mut map = std::collections::HashMap::new();
-   for line in s.lines() {
-       if let Some((k, v)) = line.split_once('=') {
-           map.insert(k.trim().to_string(), v.trim().to_string());
-       }
-   }
-   map
+    let mut map = std::collections::HashMap::new();
+    for line in s.lines() {
+        if let Some((k, v)) = line.split_once('=') {
+            map.insert(k.trim().to_string(), v.trim().to_string());
+        }
+    }
+    map
 }
 
 /// Probe existing filesystems on the system and return their identities (kind, uuid, label).
@@ -354,13 +384,16 @@ fn parse_blkid_export(s: &str) -> std::collections::HashMap<String, String> {
 /// - Vec<FsResult> with at most one entry per filesystem UUID.
 pub fn probe_existing_filesystems() -> Result<Vec<FsResult>> {
     let Some(blkid) = which_tool("blkid")? else {
-        return Err(Error::Filesystem("blkid not found in PATH; cannot probe existing filesystems".into()));
+        return Err(Error::Filesystem(
+            "blkid not found in PATH; cannot probe existing filesystems".into(),
+        ));
     };
 
     let content = fs::read_to_string("/proc/partitions")
         .map_err(|e| Error::Filesystem(format!("/proc/partitions read error: {}", e)))?;
 
-    let mut results_by_uuid: std::collections::HashMap<String, FsResult> = std::collections::HashMap::new();
+    let mut results_by_uuid: std::collections::HashMap<String, FsResult> =
+        std::collections::HashMap::new();
 
     for line in content.lines() {
         let line = line.trim();
@@ -399,11 +432,13 @@ pub fn probe_existing_filesystems() -> Result<Vec<FsResult>> {
         let map = parse_blkid_export(&out.stdout);
         let ty = map.get("TYPE").cloned().unwrap_or_default();
         let label = map
-            .get("ID_FS_LABEL").cloned()
+            .get("ID_FS_LABEL")
+            .cloned()
             .or_else(|| map.get("LABEL").cloned())
             .unwrap_or_default();
         let uuid = map
-            .get("ID_FS_UUID").cloned()
+            .get("ID_FS_UUID")
+            .cloned()
             .or_else(|| map.get("UUID").cloned());
 
         let (kind_opt, expected_label) = match ty.as_str() {
@@ -434,13 +469,13 @@ pub fn probe_existing_filesystems() -> Result<Vec<FsResult>> {
 
 #[cfg(test)]
 mod tests_parse {
-   use super::parse_blkid_export;
+    use super::parse_blkid_export;
 
-   #[test]
-   fn parse_export_ok() {
-       let s = "ID_FS_UUID=abcd-1234\nUUID=abcd-1234\nTYPE=btrfs\n";
-       let m = parse_blkid_export(s);
-       assert_eq!(m.get("ID_FS_UUID").unwrap(), "abcd-1234");
-       assert_eq!(m.get("TYPE").unwrap(), "btrfs");
-   }
+    #[test]
+    fn parse_export_ok() {
+        let s = "ID_FS_UUID=abcd-1234\nUUID=abcd-1234\nTYPE=btrfs\n";
+        let m = parse_blkid_export(s);
+        assert_eq!(m.get("ID_FS_UUID").unwrap(), "abcd-1234");
+        assert_eq!(m.get("TYPE").unwrap(), "btrfs");
+    }
 }

src/idempotency/mod.rs

@@ -28,14 +28,14 @@
 //! disks are empty before making any destructive changes.
 
 use crate::{
-    device::Disk,
-    report::{StateReport, REPORT_VERSION},
-    util::{run_cmd_capture, which_tool},
     Error, Result,
+    device::Disk,
+    report::{REPORT_VERSION, StateReport},
+    util::{run_cmd_capture, which_tool},
 };
+use humantime::format_rfc3339;
 use serde_json::json;
 use std::{collections::HashMap, fs, path::Path};
-use humantime::format_rfc3339;
 use tracing::{debug, warn};
 
 /// Return existing state if system is already provisioned; otherwise None.
@@ -155,7 +155,10 @@ pub fn is_empty_disk(disk: &Disk) -> Result<bool> {
 
     // Probe with blkid -p
     let Some(blkid) = which_tool("blkid")? else {
-        warn!("blkid not found; conservatively treating {} as not empty", disk.path);
+        warn!(
+            "blkid not found; conservatively treating {} as not empty",
+            disk.path
+        );
         return Ok(false);
     };
 
@@ -237,7 +240,11 @@ fn is_partition_of(base: &str, name: &str) -> bool {
     if name == base {
         return false;
     }
-    let ends_with_digit = base.chars().last().map(|c| c.is_ascii_digit()).unwrap_or(false);
+    let ends_with_digit = base
+        .chars()
+        .last()
+        .map(|c| c.is_ascii_digit())
+        .unwrap_or(false);
     if ends_with_digit {
         // nvme0n1 -> nvme0n1p1
         if name.starts_with(base) {

src/lib.rs

@@ -1,18 +1,18 @@
 //! Crate root for zosstorage: one-shot disk provisioning utility for initramfs.
 
 pub mod cli;
-pub mod logging;
 pub mod config;
 pub mod device;
-pub mod partition;
-pub mod fs;
-pub mod mount;
-pub mod report;
-pub mod orchestrator;
-pub mod idempotency;
-pub mod util;
 pub mod errors;
-pub mod types; // top-level types (moved from config/types.rs for visibility)
+pub mod fs;
+pub mod idempotency;
+pub mod logging;
+pub mod mount;
+pub mod orchestrator;
+pub mod partition;
+pub mod report;
+pub mod types;
+pub mod util; // top-level types (moved from config/types.rs for visibility)
 
 pub use errors::{Error, Result};
 

src/logging/mod.rs

@@ -36,10 +36,10 @@ use std::fs::OpenOptions;
 use std::io::{self};
 use std::sync::OnceLock;
 use tracing::Level;
+use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::fmt;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::registry::Registry;
-use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::util::SubscriberInitExt;
 
 /// Logging options resolved from CLI and/or config.
@@ -116,19 +116,25 @@ pub fn init_logging(opts: &LogOptions) -> Result<()> {
                 .with(stderr_layer)
                 .with(file_layer)
                 .try_init()
-                .map_err(|e| crate::Error::Other(anyhow::anyhow!("failed to set global logger: {}", e)))?;
+                .map_err(|e| {
+                    crate::Error::Other(anyhow::anyhow!("failed to set global logger: {}", e))
+                })?;
         } else {
             // Fall back to stderr-only if file cannot be opened
             Registry::default()
                 .with(stderr_layer)
                 .try_init()
-                .map_err(|e| crate::Error::Other(anyhow::anyhow!("failed to set global logger: {}", e)))?;
+                .map_err(|e| {
+                    crate::Error::Other(anyhow::anyhow!("failed to set global logger: {}", e))
+                })?;
         }
     } else {
         Registry::default()
             .with(stderr_layer)
             .try_init()
-            .map_err(|e| crate::Error::Other(anyhow::anyhow!("failed to set global logger: {}", e)))?;
+            .map_err(|e| {
+                crate::Error::Other(anyhow::anyhow!("failed to set global logger: {}", e))
+            })?;
     }
 
     let _ = INIT_GUARD.set(());

src/main.rs

@@ -56,6 +56,8 @@ fn real_main() -> Result<()> {
         .with_report_current(cli.report_current)
         .with_report_path(cli.report.clone())
         .with_topology_from_cli(cli.topology.is_some())
-        .with_topology_from_cmdline(config::loader::kernel_cmdline_topology().is_some() && cli.topology.is_none());
+        .with_topology_from_cmdline(
+            config::loader::kernel_cmdline_topology().is_some() && cli.topology.is_none(),
+        );
     orchestrator::run(&ctx)
 }

src/mount/ops.rs

@@ -7,13 +7,13 @@
 // REGION: API-END
 //
 // REGION: RESPONSIBILITIES
-// - Implement mount phase only: plan root mounts under /var/mounts/{UUID}, ensure/plan subvols, and mount subvols to /var/cache/*.
+// - Implement mount phase only: plan root mounts under /var/mounts/{UUID} for data, mount ESP at /boot, ensure/plan subvols, and mount subvols to /var/cache/*.
 // - Use UUID= sources, deterministic primary selection (first FsResult) for dual_independent.
-// - Generate fstab entries only for four subvol targets; exclude runtime root mounts.
+// - Generate fstab entries covering runtime roots (/var/mounts/{UUID}, /boot when present) followed by the four subvol targets.
 // REGION: RESPONSIBILITIES-END
 //
 // REGION: SAFETY
-// - Never mount ESP; only Btrfs/Bcachefs data FS. Root btrfs mounts use subvolid=5 (top-level).
+// - Mount ESP (VFAT) read-write at /boot once; data roots use subvolid=5 (btrfs) or plain (bcachefs).
 // - Create-if-missing subvolumes prior to subvol mounts; ensure directories exist.
 // - Always use UUID= sources; no device paths.
 // - Bcachefs subvolume mounts use option key 'X-mount.subdir={name}' (not 'subvol=').
@@ -36,18 +36,19 @@
 #![allow(dead_code)]
 
 use crate::{
+    Error, Result,
     fs::{FsKind, FsResult},
     types::Config,
     util::{run_cmd, run_cmd_capture, which_tool},
-    Error, Result,
 };
 use std::collections::HashMap;
-use std::fs::{create_dir_all, File};
+use std::fs::{File, create_dir_all};
 use std::io::Write;
 use std::path::Path;
 use tracing::info;
 
 const ROOT_BASE: &str = "/var/mounts";
+const BOOT_TARGET: &str = "/boot";
 const TARGET_SYSTEM: &str = "/var/cache/system";
 const TARGET_ETC: &str = "/var/cache/etc";
 const TARGET_MODULES: &str = "/var/cache/modules";
@@ -119,21 +120,39 @@ fn source_matches_uuid(existing_source: &str, uuid: &str) -> bool {
     false
 }
 
+fn disk_of_device(dev: &str) -> Option<String> {
+    let path = Path::new(dev);
+    let name = path.file_name()?.to_str()?;
+    let mut cutoff = name.len();
+    while cutoff > 0 && name.as_bytes()[cutoff - 1].is_ascii_digit() {
+        cutoff -= 1;
+    }
+    if cutoff == name.len() {
+        return Some(dev.to_string());
+    }
+    let mut disk = name[..cutoff].to_string();
+    if disk.ends_with('p') {
+        disk.pop();
+    }
+    let parent = path.parent()?.to_str().unwrap_or("/dev");
+    Some(format!("{}/{}", parent, disk))
+}
+
 #[derive(Debug, Clone)]
 pub struct PlannedMount {
-    pub uuid: String,     // UUID string without prefix
-    pub target: String,   // absolute path
-    pub fstype: String,   // "btrfs" | "bcachefs"
-    pub options: String,  // e.g., "rw,noatime,subvolid=5"
+    pub uuid: String,    // UUID string without prefix
+    pub target: String,  // absolute path
+    pub fstype: String,  // "btrfs" | "bcachefs"
+    pub options: String, // e.g., "rw,noatime,subvolid=5"
 }
 
 #[derive(Debug, Clone)]
 pub struct PlannedSubvolMount {
-    pub uuid: String,     // UUID of primary FS
-    pub name: String,     // subvol name (system/etc/modules/vm-meta)
-    pub target: String,   // absolute final target
-    pub fstype: String,   // "btrfs" | "bcachefs"
-    pub options: String,  // e.g., "rw,noatime,subvol=system"
+    pub uuid: String,    // UUID of primary FS
+    pub name: String,    // subvol name (system/etc/modules/vm-meta)
+    pub target: String,  // absolute final target
+    pub fstype: String,  // "btrfs" | "bcachefs"
+    pub options: String, // e.g., "rw,noatime,subvol=system"
 }
 
 /// Mount plan per policy.
@@ -201,11 +220,36 @@ pub fn plan_mounts(fs_results: &[FsResult], _cfg: &Config) -> Result<MountPlan>
         });
     }
 
-    // Determine primary UUID
-    let primary_uuid = Some(data[0].uuid.clone());
+    let primary = data[0];
+    let primary_uuid = Some(primary.uuid.clone());
+    let primary_disk = primary.devices.first().and_then(|dev| disk_of_device(dev));
+
+    let mut chosen_esp: Option<&FsResult> = None;
+    let mut fallback_esp: Option<&FsResult> = None;
+    for esp in fs_results.iter().filter(|r| matches!(r.kind, FsKind::Vfat)) {
+        if fallback_esp.is_none() {
+            fallback_esp = Some(esp);
+        }
+        if let (Some(ref disk), Some(esp_disk)) = (
+            primary_disk.as_ref(),
+            esp.devices.first().and_then(|dev| disk_of_device(dev)),
+        ) {
+            if esp_disk == **disk {
+                chosen_esp = Some(esp);
+                break;
+            }
+        }
+    }
+    if let Some(esp) = chosen_esp.or(fallback_esp) {
+        root_mounts.push(PlannedMount {
+            uuid: esp.uuid.clone(),
+            target: BOOT_TARGET.to_string(),
+            fstype: fstype_str(esp.kind).to_string(),
+            options: "rw".to_string(),
+        });
+    }
 
     // Subvol mounts only from primary FS
-    let primary = data[0];
     let mut subvol_mounts: Vec<PlannedSubvolMount> = Vec::new();
     let fstype = fstype_str(primary.kind).to_string();
     // Option key differs per filesystem: btrfs uses subvol=, bcachefs uses X-mount.subdir=
@@ -349,14 +393,18 @@ pub fn apply_mounts(plan: &MountPlan) -> Result<Vec<MountResult>> {
                 if !exists {
                     // Create subvolume
                     let subvol_path = format!("{}/{}", root, sm.name);
-                    let args = [btrfs_tool.as_str(), "subvolume", "create", subvol_path.as_str()];
+                    let args = [
+                        btrfs_tool.as_str(),
+                        "subvolume",
+                        "create",
+                        subvol_path.as_str(),
+                    ];
                     run_cmd(&args)?;
                 }
             }
         } else if primary_kind == "bcachefs" {
-            let bcachefs_tool = which_tool("bcachefs")?.ok_or_else(|| {
-                Error::Mount("required tool 'bcachefs' not found in PATH".into())
-            })?;
+            let bcachefs_tool = which_tool("bcachefs")?
+                .ok_or_else(|| Error::Mount("required tool 'bcachefs' not found in PATH".into()))?;
             for sm in &plan.subvol_mounts {
                 if &sm.uuid != primary_uuid {
                     continue;
@@ -452,7 +500,7 @@ pub fn maybe_write_fstab(mounts: &[MountResult], cfg: &Config) -> Result<()> {
     // Partition mount results into runtime root mounts and final subvolume targets.
     let mut root_entries: Vec<&MountResult> = mounts
         .iter()
-        .filter(|m| m.target.starts_with(ROOT_BASE))
+        .filter(|m| m.target.starts_with(ROOT_BASE) || m.target == BOOT_TARGET)
         .collect();
     let wanted = [TARGET_ETC, TARGET_MODULES, TARGET_SYSTEM, TARGET_VM_META];
     let mut subvol_entries: Vec<&MountResult> = mounts
@@ -468,10 +516,7 @@ pub fn maybe_write_fstab(mounts: &[MountResult], cfg: &Config) -> Result<()> {
     let mut lines: Vec<String> = Vec::new();
     for m in root_entries.into_iter().chain(subvol_entries.into_iter()) {
         // m.source already "UUID=..."
-        let line = format!(
-            "{} {} {} {} 0 0",
-            m.source, m.target, m.fstype, m.options
-        );
+        let line = format!("{} {} {} {} 0 0", m.source, m.target, m.fstype, m.options);
         lines.push(line);
     }
 

src/orchestrator/run.rs

@@ -43,14 +43,13 @@
 //! - Report generation and write
 
 use crate::{
-    types::{Config, Topology},
+    Error, Result,
+    device::{DeviceFilter, Disk, discover},
+    fs as zfs, idempotency,
     logging::LogOptions,
-    device::{discover, DeviceFilter, Disk},
-    idempotency,
     partition,
     report::StateReport,
-    fs as zfs,
-    Error, Result,
+    types::{Config, Topology},
 };
 use humantime::format_rfc3339;
 use regex::Regex;
@@ -191,9 +190,7 @@ pub fn run(ctx: &Context) -> Result<()> {
     info!("orchestrator: starting run()");
 
     let selected_modes =
-        (ctx.mount_existing as u8) +
-        (ctx.report_current as u8) +
-        (ctx.apply as u8);
+        (ctx.mount_existing as u8) + (ctx.report_current as u8) + (ctx.apply as u8);
     if selected_modes > 1 {
         return Err(Error::Validation(
             "choose only one mode: --mount-existing | --report-current | --apply".into(),
@@ -242,7 +239,11 @@ fn auto_select_mode(ctx: &Context) -> Result<AutoSelection> {
         info!("orchestrator: provisioned state detected; attempting mount-existing flow");
         return Ok(AutoSelection {
             decision: AutoDecision::MountExisting,
-            fs_results: if fs_results.is_empty() { None } else { Some(fs_results) },
+            fs_results: if fs_results.is_empty() {
+                None
+            } else {
+                Some(fs_results)
+            },
             state: Some(state),
         });
     }
@@ -275,6 +276,7 @@ fn run_report_current(ctx: &Context) -> Result<()> {
     info!("orchestrator: report-current mode");
     let fs_results = zfs::probe_existing_filesystems()?;
 
+    // Read all mounts, filtering common system/uninteresting ones
     let mounts_content = fs::read_to_string("/proc/mounts").unwrap_or_default();
     let mounts_json: Vec<serde_json::Value> = mounts_content
         .lines()
@@ -284,21 +286,77 @@ fn run_report_current(ctx: &Context) -> Result<()> {
             let target = it.next()?;
             let fstype = it.next()?;
             let options = it.next().unwrap_or("");
-            if target.starts_with("/var/mounts/")
-                || target == "/var/cache/system"
-                || target == "/var/cache/etc"
-                || target == "/var/cache/modules"
-                || target == "/var/cache/vm-meta"
+            
+            // Skip common pseudo/virtual filesystems and system mounts
+            if source.starts_with("devtmpfs")
+                || source.starts_with("tmpfs")
+                || source.starts_with("proc")
+                || source.starts_with("sysfs")
+                || source.starts_with("cgroup")
+                || source.starts_with("bpf")
+                || source.starts_with("debugfs")
+                || source.starts_with("securityfs")
+                || source.starts_with("mqueue")
+                || source.starts_with("pstore")
+                || source.starts_with("tracefs")
+                || source.starts_with("hugetlbfs")
+                || source.starts_with("efivarfs")
+                || source.starts_with("systemd-1")
+                || target.starts_with("/proc")
+                || target.starts_with("/sys")
+                || target.starts_with("/dev")
+                || target.starts_with("/run")
+                || target.starts_with("/boot")
+                || target.starts_with("/efi")
+                || target.starts_with("/boot/efi")
             {
-                Some(json!({
-                    "source": source,
-                    "target": target,
-                    "fstype": fstype,
-                    "options": options
-                }))
-            } else {
-                None
+                return None;
             }
+
+            // Include zosstorage target mounts and general data mounts
+            Some(json!({
+                "source": source,
+                "target": target,
+                "fstype": fstype,
+                "options": options
+            }))
+        })
+        .collect();
+
+    // Read partition information from /proc/partitions
+    let partitions_content = fs::read_to_string("/proc/partitions").unwrap_or_default();
+    let partitions_json: Vec<serde_json::Value> = partitions_content
+        .lines()
+        .filter_map(|line| {
+            let line = line.trim();
+            if line.is_empty() || line.starts_with("major") {
+                return None;
+            }
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.len() < 4 {
+                return None;
+            }
+            let name = parts[3];
+            // Skip pseudo devices
+            if name.starts_with("loop")
+                || name.starts_with("ram")
+                || name.starts_with("zram")
+                || name.starts_with("fd")
+                || name.starts_with("dm-")
+                || name.starts_with("md")
+            {
+                return None;
+            }
+            let major: u32 = parts[0].parse().ok()?;
+            let minor: u32 = parts[1].parse().ok()?;
+            let size_kb: u64 = parts[2].parse().ok()?;
+            Some(json!({
+                "name": name,
+                "major": major,
+                "minor": minor,
+                "size_kb": size_kb,
+                "size_gib": size_kb / (1024 * 1024)
+            }))
         })
         .collect();
 
@@ -324,15 +382,15 @@ fn run_report_current(ctx: &Context) -> Result<()> {
         "version": "v1",
         "timestamp": now,
         "status": "observed",
+        "partitions": partitions_json,
         "filesystems": fs_json,
         "mounts": mounts_json
     });
 
     println!("{}", summary);
     if let Some(path) = &ctx.report_path_override {
-        fs::write(path, summary.to_string()).map_err(|e| {
-            Error::Report(format!("failed to write report to {}: {}", path, e))
-        })?;
+        fs::write(path, summary.to_string())
+            .map_err(|e| Error::Report(format!("failed to write report to {}: {}", path, e)))?;
         info!("orchestrator: wrote report-current to {}", path);
     }
     Ok(())
@@ -409,9 +467,8 @@ fn run_mount_existing(
             println!("{}", summary);
         }
         if let Some(path) = &ctx.report_path_override {
-            fs::write(path, summary.to_string()).map_err(|e| {
-                Error::Report(format!("failed to write report to {}: {}", path, e))
-            })?;
+            fs::write(path, summary.to_string())
+                .map_err(|e| Error::Report(format!("failed to write report to {}: {}", path, e)))?;
             info!("orchestrator: wrote mount-existing report to {}", path);
         }
     }
@@ -445,7 +502,9 @@ fn run_provisioning(
             enforce_empty_disks(&disks)?;
             info!("orchestrator: all target disks verified empty");
         } else {
-            warn!("orchestrator: preview mode detected (--show/--report); skipping empty-disk enforcement");
+            warn!(
+                "orchestrator: preview mode detected (--show/--report); skipping empty-disk enforcement"
+            );
         }
     } else if matches!(mode, ProvisioningMode::Apply) {
         warn!("orchestrator: require_empty_disks=false; proceeding without emptiness enforcement");
@@ -506,7 +565,9 @@ fn run_provisioning(
         return Ok(());
     }
 
-    info!("orchestrator: pre-flight complete (idempotency checked, devices discovered, plan computed)");
+    info!(
+        "orchestrator: pre-flight complete (idempotency checked, devices discovered, plan computed)"
+    );
 
     if preview_outputs {
         let summary = build_summary_json(&disks, &plan, &effective_cfg)?;
@@ -514,9 +575,8 @@ fn run_provisioning(
             println!("{}", summary);
         }
         if let Some(path) = &ctx.report_path_override {
-            fs::write(path, summary.to_string()).map_err(|e| {
-                Error::Report(format!("failed to write report to {}: {}", path, e))
-            })?;
+            fs::write(path, summary.to_string())
+                .map_err(|e| Error::Report(format!("failed to write report to {}: {}", path, e)))?;
             info!("orchestrator: wrote summary report to {}", path);
         }
     }
@@ -536,15 +596,13 @@ fn build_device_filter(cfg: &Config) -> Result<DeviceFilter> {
     let mut exclude = Vec::new();
 
     for pat in &cfg.device_selection.include_patterns {
-        let re = Regex::new(pat).map_err(|e| {
-            Error::Validation(format!("invalid include regex '{}': {}", pat, e))
-        })?;
+        let re = Regex::new(pat)
+            .map_err(|e| Error::Validation(format!("invalid include regex '{}': {}", pat, e)))?;
         include.push(re);
     }
     for pat in &cfg.device_selection.exclude_patterns {
-        let re = Regex::new(pat).map_err(|e| {
-            Error::Validation(format!("invalid exclude regex '{}': {}", pat, e))
-        })?;
+        let re = Regex::new(pat)
+            .map_err(|e| Error::Validation(format!("invalid exclude regex '{}': {}", pat, e)))?;
         exclude.push(re);
     }
 
@@ -598,7 +656,11 @@ fn role_str(role: partition::PartRole) -> &'static str {
 /// - mount: scheme summary and target template (e.g., "/var/cache/{UUID}")
 ///
 /// This function is non-destructive and performs no probing beyond the provided inputs.
-fn build_summary_json(disks: &[Disk], plan: &partition::PartitionPlan, cfg: &Config) -> Result<serde_json::Value> {
+fn build_summary_json(
+    disks: &[Disk],
+    plan: &partition::PartitionPlan,
+    cfg: &Config,
+) -> Result<serde_json::Value> {
     // Disks summary
     let disks_json: Vec<serde_json::Value> = disks
         .iter()

src/partition/plan.rs

@@ -19,12 +19,12 @@
 // ext: device-specific alignment or reserved areas configurable via cfg in the future.
 // REGION: EXTENSION_POINTS-END
 //
- // REGION: SAFETY
- // safety: must verify require_empty_disks before any modification.
- // safety: when UEFI-booted, suppress creating BIOS boot partition to avoid unnecessary ef02 on UEFI systems.
- // safety: must ensure unique partition GUIDs; identical labels are allowed when expected (e.g., ESP ZOSBOOT).
- // safety: must call udev settle after partition table writes.
- // REGION: SAFETY-END
+// REGION: SAFETY
+// safety: must verify require_empty_disks before any modification.
+// safety: when UEFI-booted, suppress creating BIOS boot partition to avoid unnecessary ef02 on UEFI systems.
+// safety: must ensure unique partition GUIDs; identical labels are allowed when expected (e.g., ESP ZOSBOOT).
+// safety: must call udev settle after partition table writes.
+// REGION: SAFETY-END
 //
 // REGION: ERROR_MAPPING
 // errmap: external tool failure -> crate::Error::Tool { tool, status, stderr }.
@@ -44,11 +44,11 @@
 //! [fn apply_partitions](plan.rs:1).
 
 use crate::{
-    types::{Config, Topology},
-    device::Disk,
-    util::{run_cmd, run_cmd_capture, which_tool, udev_settle, is_efi_boot},
-    idempotency,
     Error, Result,
+    device::Disk,
+    idempotency,
+    types::{Config, Topology},
+    util::{is_efi_boot, run_cmd, run_cmd_capture, udev_settle, which_tool},
 };
 use tracing::{debug, warn};
 
@@ -117,20 +117,20 @@ pub struct PartitionResult {
     pub device_path: String,
 }
 
-    /// Compute GPT-only plan per topology and constraints.
-    ///
-    /// Layout defaults:
-    /// - BIOS boot: cfg.partitioning.bios_boot if enabled (size_mib)
-    /// - ESP: cfg.partitioning.esp.size_mib, GPT name cfg.partitioning.esp.gpt_name (typically "zosboot")
-    /// - Data: remainder, GPT name cfg.partitioning.data.gpt_name ("zosdata")
-    /// - Cache (only for SSD/HDD topology): remainder on SSD after boot/ESP, GPT name cfg.partitioning.cache.gpt_name ("zoscache")
-    ///
-    /// Topology mapping:
-    /// - Single: use first eligible disk; create BIOS (opt) + ESP + Data
-    /// - DualIndependent: need at least 2 disks; disk0: BIOS (opt) + ESP + Data, disk1: Data
-    /// - BtrfsRaid1: need at least 2 disks; disk0: BIOS (opt) + ESP + Data, disk1: Data
-    /// - SsdHddBcachefs: need >=1 SSD (rotational=false) and >=1 HDD (rotational=true);
-    ///     SSD: BIOS (opt) + ESP + Cache; HDD: Data
+/// Compute GPT-only plan per topology and constraints.
+///
+/// Layout defaults:
+/// - BIOS boot: cfg.partitioning.bios_boot if enabled (size_mib)
+/// - ESP: cfg.partitioning.esp.size_mib, GPT name cfg.partitioning.esp.gpt_name (typically "zosboot")
+/// - Data: remainder, GPT name cfg.partitioning.data.gpt_name ("zosdata")
+/// - Cache (only for SSD/HDD topology): remainder on SSD after boot/ESP, GPT name cfg.partitioning.cache.gpt_name ("zoscache")
+///
+/// Topology mapping:
+/// - Single: use first eligible disk; create BIOS (opt) + ESP + Data
+/// - DualIndependent: need at least 2 disks; disk0: BIOS (opt) + ESP + Data, disk1: Data
+/// - BtrfsRaid1: need at least 2 disks; disk0: BIOS (opt) + ESP + Data, disk1: Data
+/// - SsdHddBcachefs: need >=1 SSD (rotational=false) and >=1 HDD (rotational=true);
+///     SSD: BIOS (opt) + ESP + Cache; HDD: Data
 pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
     let align = cfg.partitioning.alignment_mib;
     let require_empty = cfg.partitioning.require_empty_disks;
@@ -138,7 +138,9 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
     let add_bios = cfg.partitioning.bios_boot.enabled && !is_efi_boot();
 
     if disks.is_empty() {
-        return Err(Error::Partition("no disks provided to partition planner".into()));
+        return Err(Error::Partition(
+            "no disks provided to partition planner".into(),
+        ));
     }
 
     let mut plans: Vec<DiskPlan> = Vec::new();
@@ -164,7 +166,10 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d0.clone(), parts });
+            plans.push(DiskPlan {
+                disk: d0.clone(),
+                parts,
+            });
         }
         Topology::BcachefsSingle => {
             let d0 = &disks[0];
@@ -186,11 +191,16 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d0.clone(), parts });
+            plans.push(DiskPlan {
+                disk: d0.clone(),
+                parts,
+            });
         }
         Topology::DualIndependent => {
             if disks.len() < 2 {
-                return Err(Error::Partition("DualIndependent topology requires at least 2 disks".into()));
+                return Err(Error::Partition(
+                    "DualIndependent topology requires at least 2 disks".into(),
+                ));
             }
             let d0 = &disks[0];
             let d1 = &disks[1];
@@ -214,7 +224,10 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d0.clone(), parts: parts0 });
+            plans.push(DiskPlan {
+                disk: d0.clone(),
+                parts: parts0,
+            });
 
             // Disk 1: Data only
             let mut parts1 = Vec::new();
@@ -223,11 +236,16 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d1.clone(), parts: parts1 });
+            plans.push(DiskPlan {
+                disk: d1.clone(),
+                parts: parts1,
+            });
         }
         Topology::BtrfsRaid1 => {
             if disks.len() < 2 {
-                return Err(Error::Partition("BtrfsRaid1 topology requires at least 2 disks".into()));
+                return Err(Error::Partition(
+                    "BtrfsRaid1 topology requires at least 2 disks".into(),
+                ));
             }
             let d0 = &disks[0];
             let d1 = &disks[1];
@@ -251,7 +269,10 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d0.clone(), parts: parts0 });
+            plans.push(DiskPlan {
+                disk: d0.clone(),
+                parts: parts0,
+            });
 
             // Disk 1: Data only (for RAID1)
             let mut parts1 = Vec::new();
@@ -260,11 +281,16 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d1.clone(), parts: parts1 });
+            plans.push(DiskPlan {
+                disk: d1.clone(),
+                parts: parts1,
+            });
         }
         Topology::Bcachefs2Copy => {
             if disks.len() < 2 {
-                return Err(Error::Partition("Bcachefs2Copy topology requires at least 2 disks".into()));
+                return Err(Error::Partition(
+                    "Bcachefs2Copy topology requires at least 2 disks".into(),
+                ));
             }
             let d0 = &disks[0];
             let d1 = &disks[1];
@@ -288,7 +314,10 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d0.clone(), parts: parts0 });
+            plans.push(DiskPlan {
+                disk: d0.clone(),
+                parts: parts0,
+            });
 
             // Disk 1: Data only
             let mut parts1 = Vec::new();
@@ -297,14 +326,19 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: d1.clone(), parts: parts1 });
+            plans.push(DiskPlan {
+                disk: d1.clone(),
+                parts: parts1,
+            });
         }
         Topology::SsdHddBcachefs => {
             // Choose SSD (rotational=false) and HDD (rotational=true)
-            let ssd = disks.iter().find(|d| !d.rotational)
-                .ok_or_else(|| Error::Partition("SsdHddBcachefs requires an SSD (non-rotational) disk".into()))?;
-            let hdd = disks.iter().find(|d| d.rotational)
-                .ok_or_else(|| Error::Partition("SsdHddBcachefs requires an HDD (rotational) disk".into()))?;
+            let ssd = disks.iter().find(|d| !d.rotational).ok_or_else(|| {
+                Error::Partition("SsdHddBcachefs requires an SSD (non-rotational) disk".into())
+            })?;
+            let hdd = disks.iter().find(|d| d.rotational).ok_or_else(|| {
+                Error::Partition("SsdHddBcachefs requires an HDD (rotational) disk".into())
+            })?;
 
             // SSD: BIOS (opt) + ESP + Cache remainder
             let mut parts_ssd = Vec::new();
@@ -325,7 +359,10 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.cache.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: ssd.clone(), parts: parts_ssd });
+            plans.push(DiskPlan {
+                disk: ssd.clone(),
+                parts: parts_ssd,
+            });
 
             // HDD: Data remainder
             let mut parts_hdd = Vec::new();
@@ -334,7 +371,10 @@ pub fn plan_partitions(disks: &[Disk], cfg: &Config) -> Result<PartitionPlan> {
                 size_mib: None,
                 gpt_name: cfg.partitioning.data.gpt_name.clone(),
             });
-            plans.push(DiskPlan { disk: hdd.clone(), parts: parts_hdd });
+            plans.push(DiskPlan {
+                disk: hdd.clone(),
+                parts: parts_hdd,
+            });
         }
     }
 
@@ -389,10 +429,17 @@ pub fn apply_partitions(plan: &PartitionPlan) -> Result<Vec<PartitionResult>> {
         if let Some(blockdev) = which_tool("blockdev")? {
             let out = run_cmd_capture(&[blockdev.as_str(), "--getss", disk_path])?;
             let s = out.stdout.trim();
-            return s.parse::<u64>()
-                .map_err(|e| Error::Partition(format!("failed to parse sector size from blockdev for {}: {}", disk_path, e)));
+            return s.parse::<u64>().map_err(|e| {
+                Error::Partition(format!(
+                    "failed to parse sector size from blockdev for {}: {}",
+                    disk_path, e
+                ))
+            });
         }
-        warn!("blockdev not found; assuming 512-byte sectors for {}", disk_path);
+        warn!(
+            "blockdev not found; assuming 512-byte sectors for {}",
+            disk_path
+        );
         Ok(512)
     }
 
@@ -410,20 +457,29 @@ pub fn apply_partitions(plan: &PartitionPlan) -> Result<Vec<PartitionResult>> {
                 // Format: "First sector: 2048 (at 1024.0 KiB)"
                 let val = rest.trim().split_whitespace().next().unwrap_or("");
                 if !val.is_empty() {
-                    first = Some(val.parse::<u64>().map_err(|e| Error::Partition(format!("parse first sector: {}", e)))?);
+                    first = Some(
+                        val.parse::<u64>()
+                            .map_err(|e| Error::Partition(format!("parse first sector: {}", e)))?,
+                    );
                 }
             } else if let Some(rest) = line.strip_prefix("Last sector:") {
                 let val = rest.trim().split_whitespace().next().unwrap_or("");
                 if !val.is_empty() {
-                    last = Some(val.parse::<u64>().map_err(|e| Error::Partition(format!("parse last sector: {}", e)))?);
+                    last = Some(
+                        val.parse::<u64>()
+                            .map_err(|e| Error::Partition(format!("parse last sector: {}", e)))?,
+                    );
                 }
             }
         }
 
-        let first = first.ok_or_else(|| Error::Partition("sgdisk -i missing First sector".into()))?;
+        let first =
+            first.ok_or_else(|| Error::Partition("sgdisk -i missing First sector".into()))?;
         let last = last.ok_or_else(|| Error::Partition("sgdisk -i missing Last sector".into()))?;
         if guid.is_empty() {
-            return Err(Error::Partition("sgdisk -i missing Partition unique GUID".into()));
+            return Err(Error::Partition(
+                "sgdisk -i missing Partition unique GUID".into(),
+            ));
         }
         Ok((guid, first, last))
     }
@@ -467,9 +523,12 @@ pub fn apply_partitions(plan: &PartitionPlan) -> Result<Vec<PartitionResult>> {
 
             run_cmd(&[
                 sgdisk.as_str(),
-                "-n", n_arg.as_str(),
-                "-t", t_arg.as_str(),
-                "-c", c_arg.as_str(),
+                "-n",
+                n_arg.as_str(),
+                "-t",
+                t_arg.as_str(),
+                "-c",
+                c_arg.as_str(),
                 disk_path,
             ])?;
         }
@@ -486,11 +545,7 @@ pub fn apply_partitions(plan: &PartitionPlan) -> Result<Vec<PartitionResult>> {
 
             // Query sgdisk for partition info
             let i_arg = format!("{}", part_num);
-            let info_out = run_cmd_capture(&[
-                sgdisk.as_str(),
-                "-i", i_arg.as_str(),
-                disk_path,
-            ])?;
+            let info_out = run_cmd_capture(&[sgdisk.as_str(), "-i", i_arg.as_str(), disk_path])?;
 
             let (unique_guid, first_sector, last_sector) = parse_sgdisk_info(&info_out.stdout)?;
             let sectors = if last_sector >= first_sector {
@@ -516,6 +571,9 @@ pub fn apply_partitions(plan: &PartitionPlan) -> Result<Vec<PartitionResult>> {
         }
     }
 
-    debug!("apply_partitions: created {} partition entries", results.len());
+    debug!(
+        "apply_partitions: created {} partition entries",
+        results.len()
+    );
     Ok(results)
 }

src/types.rs

@@ -15,15 +15,25 @@
 // - Keep field names and enums stable; update docs/SCHEMA.md when public surface changes.
 // REGION: RESPONSIBILITIES-END
 
-use serde::{Deserialize, Serialize};
 use clap::ValueEnum;
+use serde::{Deserialize, Serialize};
+
+/// Reserved filesystem labels.
+pub const LABEL_ZOSBOOT: &str = "ZOSBOOT";
+pub const LABEL_ZOSDATA: &str = "ZOSDATA";
+pub const LABEL_ZOSCACHE: &str = "ZOSCACHE";
+
+/// Reserved GPT partition names.
+pub const GPT_NAME_ZOSBOOT: &str = "zosboot";
+pub const GPT_NAME_ZOSDATA: &str = "zosdata";
+pub const GPT_NAME_ZOSCACHE: &str = "zoscache";
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LoggingConfig {
     /// Log level: "error" | "warn" | "info" | "debug"
-    pub level: String,     // default "info"
+    pub level: String, // default "info"
     /// When true, also log to /run/zosstorage/zosstorage.log
-    pub to_file: bool,     // default false
+    pub to_file: bool, // default false
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -55,7 +65,9 @@ pub enum Topology {
     #[value(alias = "ssd-hdd-bcachefs")]
     SsdHddBcachefs,
     /// Multi-device bcachefs with two replicas (data+metadata).
-    #[value(alias = "bcachefs2-copy", alias = "bcachefs-2copy", alias = "bcachefs-2-copy")]
+    /// Canonical token: bcachefs-2copy
+    #[serde(rename = "bcachefs-2copy")]
+    #[value(alias = "bcachefs-2copy")]
     Bcachefs2Copy,
     /// Optional mirrored btrfs across two disks when explicitly requested.
     #[value(alias = "btrfs-raid1")]
@@ -69,7 +81,8 @@ impl std::fmt::Display for Topology {
             Topology::BcachefsSingle => "bcachefs_single",
             Topology::DualIndependent => "dual_independent",
             Topology::SsdHddBcachefs => "ssd_hdd_bcachefs",
-            Topology::Bcachefs2Copy => "bcachefs2_copy",
+            // Canonical single notation for two-copy bcachefs topology
+            Topology::Bcachefs2Copy => "bcachefs-2copy",
             Topology::BtrfsRaid1 => "btrfs_raid1",
         };
         f.write_str(s)

src/util/mod.rs

@@ -40,8 +40,8 @@
 //! and consistent error handling.
 
 use crate::{Error, Result};
-use std::process::Command;
 use std::path::Path;
+use std::process::Command;
 use tracing::{debug, warn};
 
 /// Captured output from an external tool invocation.
@@ -77,9 +77,10 @@ pub fn run_cmd(args: &[&str]) -> Result<()> {
         )));
     }
     debug!(target: "util.run_cmd", "exec: {:?}", args);
-    let output = Command::new(args[0]).args(&args[1..]).output().map_err(|e| {
-        Error::Other(anyhow::anyhow!("failed to spawn {:?}: {}", args, e))
-    })?;
+    let output = Command::new(args[0])
+        .args(&args[1..])
+        .output()
+        .map_err(|e| Error::Other(anyhow::anyhow!("failed to spawn {:?}: {}", args, e)))?;
 
     let status_code = output.status.code().unwrap_or(-1);
     if !output.status.success() {
@@ -103,9 +104,10 @@ pub fn run_cmd_capture(args: &[&str]) -> Result<CmdOutput> {
         )));
     }
     debug!(target: "util.run_cmd_capture", "exec: {:?}", args);
-    let output = Command::new(args[0]).args(&args[1..]).output().map_err(|e| {
-        Error::Other(anyhow::anyhow!("failed to spawn {:?}: {}", args, e))
-    })?;
+    let output = Command::new(args[0])
+        .args(&args[1..])
+        .output()
+        .map_err(|e| Error::Other(anyhow::anyhow!("failed to spawn {:?}: {}", args, e)))?;
     let status_code = output.status.code().unwrap_or(-1);
     let stdout = String::from_utf8_lossy(&output.stdout).to_string();
     let stderr = String::from_utf8_lossy(&output.stderr).to_string();