diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 96fa2db..9ad34ce 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -42,7 +42,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: Build
-        run: just build
+        run: just check && just build
         
       - name: Run unit tests
         run: just unit
diff --git a/Justfile b/Justfile
index c2ca1b9..fe3deb3 100644
--- a/Justfile
+++ b/Justfile
@@ -2,8 +2,10 @@
 build:
    make
 
+# Quick checks
 check:
     cargo t --workspace --no-run
+    cargo fmt --check
 
 # Run unit tests (excludes integration tests)
 unit *ARGS:
diff --git a/crates/integration-tests/src/bin/cleanup.rs b/crates/integration-tests/src/bin/cleanup.rs
index 98ecbf1..bea3c9c 100644
--- a/crates/integration-tests/src/bin/cleanup.rs
+++ b/crates/integration-tests/src/bin/cleanup.rs
@@ -1,7 +1,7 @@
 use std::process::Command;
 
-/// Label used to identify containers created by integration tests
-const INTEGRATION_TEST_LABEL: &str = "bcvk.integration-test=1";
+// Import shared constants from the library
+use integration_tests::{INTEGRATION_TEST_LABEL, LIBVIRT_INTEGRATION_TEST_LABEL};
 
 fn cleanup_integration_test_containers() -> Result<(), Box<dyn std::error::Error>> {
     println!("Cleaning up integration test containers...");
@@ -59,9 +59,63 @@ fn cleanup_integration_test_containers() -> Result<(), Box<dyn std::error::Error
     Ok(())
 }
 
+fn cleanup_libvirt_integration_test_vms() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Cleaning up integration test libvirt VMs...");
+
+    // Get path to bcvk binary (should be in the same directory as this cleanup binary)
+    let current_exe = std::env::current_exe()?;
+    let bcvk_path = current_exe
+        .parent()
+        .ok_or("Failed to get parent directory")?
+        .join("bcvk");
+
+    if !bcvk_path.exists() {
+        println!(
+            "bcvk binary not found at {:?}, skipping libvirt cleanup",
+            bcvk_path
+        );
+        return Ok(());
+    }
+
+    // Use bcvk libvirt rm-all with label filter
+    let rm_output = Command::new(&bcvk_path)
+        .args([
+            "libvirt",
+            "rm-all",
+            "--label",
+            LIBVIRT_INTEGRATION_TEST_LABEL,
+            "--force",
+            "--stop",
+        ])
+        .output()?;
+
+    if !rm_output.status.success() {
+        let stderr = String::from_utf8_lossy(&rm_output.stderr);
+        eprintln!("Warning: Failed to clean up libvirt VMs: {}", stderr);
+        return Ok(());
+    }
+
+    let stdout = String::from_utf8_lossy(&rm_output.stdout);
+    println!("{}", stdout);
+
+    Ok(())
+}
+
 fn main() {
+    let mut errors = Vec::new();
+
     if let Err(e) = cleanup_integration_test_containers() {
-        eprintln!("Error during cleanup: {}", e);
+        eprintln!("Error during container cleanup: {}", e);
+        errors.push(format!("containers: {}", e));
+    }
+
+    if let Err(e) = cleanup_libvirt_integration_test_vms() {
+        eprintln!("Error during libvirt VM cleanup: {}", e);
+        errors.push(format!("libvirt: {}", e));
+    }
+
+    if !errors.is_empty() {
+        eprintln!("Cleanup completed with errors: {}", errors.join(", "));
         std::process::exit(1);
     }
 }
diff --git a/crates/integration-tests/src/lib.rs b/crates/integration-tests/src/lib.rs
new file mode 100644
index 0000000..e3bbe63
--- /dev/null
+++ b/crates/integration-tests/src/lib.rs
@@ -0,0 +1,10 @@
+//! Shared library code for integration tests
+//!
+//! This module contains constants and utilities that are shared between
+//! the main test binary and helper binaries like cleanup.
+
+/// Label used to identify containers created by integration tests
+pub const INTEGRATION_TEST_LABEL: &str = "bcvk.integration-test=1";
+
+/// Label used to identify libvirt VMs created by integration tests
+pub const LIBVIRT_INTEGRATION_TEST_LABEL: &str = "bcvk-integration";
diff --git a/crates/integration-tests/src/main.rs b/crates/integration-tests/src/main.rs
index 0955b32..5668546 100644
--- a/crates/integration-tests/src/main.rs
+++ b/crates/integration-tests/src/main.rs
@@ -6,8 +6,8 @@ use libtest_mimic::{Arguments, Trial};
 use serde_json::Value;
 use xshell::{cmd, Shell};
 
-/// Label used to identify containers created by integration tests
-pub(crate) const INTEGRATION_TEST_LABEL: &str = "bcvk.integration-test=1";
+// Re-export constants from lib for internal use
+pub(crate) use integration_tests::{INTEGRATION_TEST_LABEL, LIBVIRT_INTEGRATION_TEST_LABEL};
 
 mod tests {
     pub mod libvirt_base_disks;
@@ -205,6 +205,10 @@ fn main() {
             tests::libvirt_verb::test_libvirt_vm_lifecycle();
             Ok(())
         }),
+        Trial::test("libvirt_label_functionality", || {
+            tests::libvirt_verb::test_libvirt_label_functionality();
+            Ok(())
+        }),
         Trial::test("libvirt_error_handling", || {
             tests::libvirt_verb::test_libvirt_error_handling();
             Ok(())
diff --git a/crates/integration-tests/src/tests/libvirt_verb.rs b/crates/integration-tests/src/tests/libvirt_verb.rs
index 433b5e8..96b56df 100644
--- a/crates/integration-tests/src/tests/libvirt_verb.rs
+++ b/crates/integration-tests/src/tests/libvirt_verb.rs
@@ -9,7 +9,7 @@
 
 use std::process::Command;
 
-use crate::{get_bck_command, get_test_image};
+use crate::{get_bck_command, get_test_image, LIBVIRT_INTEGRATION_TEST_LABEL};
 
 /// Test libvirt list functionality (lists domains)
 pub fn test_libvirt_list_functionality() {
@@ -224,6 +224,8 @@ pub fn test_libvirt_run_ssh_full_workflow() {
             "run",
             "--name",
             &domain_name,
+            "--label",
+            LIBVIRT_INTEGRATION_TEST_LABEL,
             "--filesystem",
             "ext4",
             &test_image,
@@ -416,6 +418,8 @@ pub fn test_libvirt_vm_lifecycle() {
             "ext4",
             "--name",
             &domain_name,
+            "--label",
+            LIBVIRT_INTEGRATION_TEST_LABEL,
             test_image,
         ])
         .output()
@@ -526,6 +530,8 @@ pub fn test_libvirt_bind_storage_ro() {
             "run",
             "--name",
             &domain_name,
+            "--label",
+            LIBVIRT_INTEGRATION_TEST_LABEL,
             "--bind-storage-ro",
             "--filesystem",
             "ext4",
@@ -699,6 +705,144 @@ pub fn test_libvirt_bind_storage_ro() {
     println!("✓ --bind-storage-ro end-to-end test passed");
 }
 
+/// Test libvirt label functionality
+pub fn test_libvirt_label_functionality() {
+    let bck = get_bck_command().unwrap();
+    let test_image = get_test_image();
+
+    // Generate unique domain name for this test
+    let domain_name = format!(
+        "test-label-{}",
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    );
+
+    println!(
+        "Testing libvirt label functionality with domain: {}",
+        domain_name
+    );
+
+    // Cleanup any existing domain with this name
+    let _ = Command::new("virsh")
+        .args(&["destroy", &domain_name])
+        .output();
+    let _ = Command::new(&bck)
+        .args(&["libvirt", "rm", &domain_name, "--force", "--stop"])
+        .output();
+
+    // Create domain with multiple labels
+    println!("Creating libvirt domain with multiple labels...");
+    let create_output = Command::new("timeout")
+        .args([
+            "300s",
+            &bck,
+            "libvirt",
+            "run",
+            "--name",
+            &domain_name,
+            "--label",
+            LIBVIRT_INTEGRATION_TEST_LABEL,
+            "--label",
+            "test-env",
+            "--label",
+            "temporary",
+            "--filesystem",
+            "ext4",
+            &test_image,
+        ])
+        .output()
+        .expect("Failed to run libvirt run with labels");
+
+    let create_stdout = String::from_utf8_lossy(&create_output.stdout);
+    let create_stderr = String::from_utf8_lossy(&create_output.stderr);
+
+    println!("Create stdout: {}", create_stdout);
+    println!("Create stderr: {}", create_stderr);
+
+    if !create_output.status.success() {
+        cleanup_domain(&domain_name);
+        panic!("Failed to create domain with labels: {}", create_stderr);
+    }
+
+    println!("Successfully created domain with labels: {}", domain_name);
+
+    // Verify labels are stored in domain XML
+    println!("Checking domain XML for labels...");
+    let dumpxml_output = Command::new("virsh")
+        .args(&["dumpxml", &domain_name])
+        .output()
+        .expect("Failed to dump domain XML");
+
+    let domain_xml = String::from_utf8_lossy(&dumpxml_output.stdout);
+
+    // Check that labels are in the XML
+    assert!(
+        domain_xml.contains("bootc:label") || domain_xml.contains("<label>"),
+        "Domain XML should contain label metadata"
+    );
+    assert!(
+        domain_xml.contains(LIBVIRT_INTEGRATION_TEST_LABEL),
+        "Domain XML should contain bcvk-integration label"
+    );
+
+    // Test filtering by label
+    println!("Testing label filtering with libvirt list...");
+    let list_output = Command::new(&bck)
+        .args([
+            "libvirt",
+            "list",
+            "--label",
+            LIBVIRT_INTEGRATION_TEST_LABEL,
+            "-a",
+        ])
+        .output()
+        .expect("Failed to run libvirt list with label filter");
+
+    let list_stdout = String::from_utf8_lossy(&list_output.stdout);
+    println!("List output: {}", list_stdout);
+
+    assert!(
+        list_output.status.success(),
+        "libvirt list with label filter should succeed"
+    );
+    assert!(
+        list_stdout.contains(&domain_name),
+        "Domain should appear in filtered list. Output: {}",
+        list_stdout
+    );
+
+    // Test filtering by a label that should match
+    let list_test_env = Command::new(&bck)
+        .args(["libvirt", "list", "--label", "test-env", "-a"])
+        .output()
+        .expect("Failed to run libvirt list with test-env label");
+
+    let list_test_env_stdout = String::from_utf8_lossy(&list_test_env.stdout);
+    assert!(
+        list_test_env_stdout.contains(&domain_name),
+        "Domain should appear when filtering by test-env label"
+    );
+
+    // Test filtering by a label that should NOT match
+    let list_nomatch = Command::new(&bck)
+        .args(["libvirt", "list", "--label", "nonexistent-label", "-a"])
+        .output()
+        .expect("Failed to run libvirt list with nonexistent label");
+
+    let list_nomatch_stdout = String::from_utf8_lossy(&list_nomatch.stdout);
+    assert!(
+        !list_nomatch_stdout.contains(&domain_name),
+        "Domain should NOT appear when filtering by nonexistent label"
+    );
+
+    // Cleanup domain
+    cleanup_domain(&domain_name);
+
+    println!("✓ Label functionality test passed");
+}
+
 /// Test error handling for invalid configurations
 pub fn test_libvirt_error_handling() {
     let bck = get_bck_command().unwrap();
diff --git a/crates/kit/src/domain_list.rs b/crates/kit/src/domain_list.rs
index 2d1b80e..68b562f 100644
--- a/crates/kit/src/domain_list.rs
+++ b/crates/kit/src/domain_list.rs
@@ -22,10 +22,12 @@ pub struct PodmanBootcDomain {
     pub created: Option<SystemTime>,
     /// Memory allocation in MB
     pub memory_mb: Option<u32>,
-    /// Number of virtual CPUs  
+    /// Number of virtual CPUs
     pub vcpus: Option<u32>,
     /// Disk path
     pub disk_path: Option<String>,
+    /// User-defined labels for organizing domains
+    pub labels: Vec<String>,
 }
 
 impl PodmanBootcDomain {
@@ -176,6 +178,19 @@ impl DomainLister {
             .or_else(|| dom.find("created"))
             .map(|node| node.text_content().to_string());
 
+        // Extract labels (comma-separated)
+        let labels = dom
+            .find("bootc:label")
+            .or_else(|| dom.find("label"))
+            .map(|node| {
+                node.text_content()
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .filter(|s| !s.is_empty())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+
         // Extract memory and vcpu from domain XML
         let memory_mb = dom.find("memory").and_then(|node| {
             // Memory might have unit attribute, but we'll try to parse the value
@@ -195,6 +210,7 @@ impl DomainLister {
             memory_mb,
             vcpus,
             disk_path,
+            labels,
         }))
     }
 
@@ -223,6 +239,10 @@ impl DomainLister {
             memory_mb: metadata.as_ref().and_then(|m| m.memory_mb),
             vcpus: metadata.as_ref().and_then(|m| m.vcpus),
             disk_path: metadata.as_ref().and_then(|m| m.disk_path.clone()),
+            labels: metadata
+                .as_ref()
+                .map(|m| m.labels.clone())
+                .unwrap_or_default(),
         })
     }
 
@@ -284,6 +304,7 @@ struct PodmanBootcDomainMetadata {
     memory_mb: Option<u32>,
     vcpus: Option<u32>,
     disk_path: Option<String>,
+    labels: Vec<String>,
 }
 
 /// Extract disk path from domain XML using DOM parser
@@ -384,6 +405,7 @@ mod tests {
             memory_mb: None,
             vcpus: None,
             disk_path: None,
+            labels: vec![],
         };
 
         assert!(domain.is_running());
@@ -398,6 +420,7 @@ mod tests {
             memory_mb: None,
             vcpus: None,
             disk_path: None,
+            labels: vec![],
         };
 
         assert!(!stopped_domain.is_running());
diff --git a/crates/kit/src/libvirt/list.rs b/crates/kit/src/libvirt/list.rs
index f28dd9a..3569e83 100644
--- a/crates/kit/src/libvirt/list.rs
+++ b/crates/kit/src/libvirt/list.rs
@@ -16,6 +16,10 @@ pub struct LibvirtListOpts {
     /// Show all domains including stopped ones
     #[clap(long, short = 'a')]
     pub all: bool,
+
+    /// Filter domains by label
+    #[clap(long)]
+    pub label: Option<String>,
 }
 
 /// Execute the libvirt list command
@@ -30,7 +34,7 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtListOpts)
         None => DomainLister::new(),
     };
 
-    let domains = if opts.all {
+    let mut domains = if opts.all {
         lister
             .list_bootc_domains()
             .with_context(|| "Failed to list bootc domains from libvirt")?
@@ -40,6 +44,11 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtListOpts)
             .with_context(|| "Failed to list running bootc domains from libvirt")?
     };
 
+    // Filter by label if specified
+    if let Some(ref filter_label) = opts.label {
+        domains.retain(|d| d.labels.contains(filter_label));
+    }
+
     match opts.format.as_str() {
         "table" => {
             if domains.is_empty() {
diff --git a/crates/kit/src/libvirt/mod.rs b/crates/kit/src/libvirt/mod.rs
index 4b9b57e..3e0eb7c 100644
--- a/crates/kit/src/libvirt/mod.rs
+++ b/crates/kit/src/libvirt/mod.rs
@@ -24,6 +24,7 @@ pub mod inspect;
 pub mod list;
 pub mod list_volumes;
 pub mod rm;
+pub mod rm_all;
 pub mod run;
 pub mod secureboot;
 pub mod ssh;
@@ -80,6 +81,10 @@ pub enum LibvirtSubcommands {
     #[clap(name = "rm")]
     Remove(rm::LibvirtRmOpts),
 
+    /// Remove multiple libvirt domains and their resources
+    #[clap(name = "rm-all")]
+    RemoveAll(rm_all::LibvirtRmAllOpts),
+
     /// Show detailed information about a libvirt domain
     Inspect(inspect::LibvirtInspectOpts),
 
diff --git a/crates/kit/src/libvirt/rm_all.rs b/crates/kit/src/libvirt/rm_all.rs
new file mode 100644
index 0000000..ae2ef66
--- /dev/null
+++ b/crates/kit/src/libvirt/rm_all.rs
@@ -0,0 +1,164 @@
+//! libvirt rm-all command - remove multiple bootc domains and their resources
+//!
+//! This module provides functionality to remove multiple libvirt domains
+//! and their associated resources at once, with optional label filtering.
+
+use clap::Parser;
+use color_eyre::Result;
+
+/// Options for removing multiple libvirt domains
+#[derive(Debug, Parser)]
+pub struct LibvirtRmAllOpts {
+    /// Force removal without confirmation
+    #[clap(long, short = 'f')]
+    pub force: bool,
+
+    /// Remove domains even if they're running
+    #[clap(long)]
+    pub stop: bool,
+
+    /// Filter domains by label (only remove domains with this label)
+    #[clap(long)]
+    pub label: Option<String>,
+}
+
+/// Execute the libvirt rm-all command
+pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRmAllOpts) -> Result<()> {
+    use crate::domain_list::DomainLister;
+    use color_eyre::eyre::Context;
+
+    let connect_uri = global_opts.connect.as_ref();
+    let lister = match connect_uri {
+        Some(uri) => DomainLister::with_connection(uri.clone()),
+        None => DomainLister::new(),
+    };
+
+    // Get all bootc domains
+    let mut domains = lister
+        .list_bootc_domains()
+        .with_context(|| "Failed to list bootc domains from libvirt")?;
+
+    // Filter by label if specified
+    if let Some(ref filter_label) = opts.label {
+        domains.retain(|d| d.labels.contains(filter_label));
+    }
+
+    if domains.is_empty() {
+        if let Some(ref label) = opts.label {
+            println!("No VMs found with label '{}'", label);
+        } else {
+            println!("No VMs found");
+        }
+        return Ok(());
+    }
+
+    // Confirmation prompt
+    if !opts.force {
+        println!(
+            "This will permanently delete {} VM{} and their data:",
+            domains.len(),
+            if domains.len() == 1 { "" } else { "s" }
+        );
+        for domain in &domains {
+            println!("  - {} ({})", domain.name, domain.status_string());
+            if let Some(ref image) = domain.image {
+                println!("    Image: {}", image);
+            }
+            if let Some(ref disk_path) = domain.disk_path {
+                println!("    Disk: {}", disk_path);
+            }
+            if !domain.labels.is_empty() {
+                println!("    Labels: {}", domain.labels.join(", "));
+            }
+        }
+        println!();
+        println!("Are you sure? This cannot be undone. Use --force to skip this prompt.");
+        return Ok(());
+    }
+
+    let mut removed_count = 0;
+    let mut error_count = 0;
+
+    for domain in &domains {
+        println!("Removing VM '{}'...", domain.name);
+
+        // Stop if running
+        if domain.is_running() {
+            if opts.stop {
+                println!("  Stopping running VM...");
+                let output = global_opts
+                    .virsh_command()
+                    .args(&["destroy", &domain.name])
+                    .output()
+                    .with_context(|| format!("Failed to stop VM '{}'", domain.name))?;
+
+                if !output.status.success() {
+                    let stderr = String::from_utf8_lossy(&output.stderr);
+                    eprintln!("  Failed to stop VM '{}': {}", domain.name, stderr);
+                    error_count += 1;
+                    continue;
+                }
+            } else {
+                eprintln!(
+                    "  Skipping '{}': VM is running. Use --stop to force removal.",
+                    domain.name
+                );
+                error_count += 1;
+                continue;
+            }
+        }
+
+        // Remove disk manually if it exists (unmanaged storage)
+        if let Some(ref disk_path) = domain.disk_path {
+            if std::path::Path::new(disk_path).exists() {
+                println!("  Removing disk image...");
+                if let Err(e) = std::fs::remove_file(disk_path) {
+                    eprintln!(
+                        "  Warning: Failed to remove disk file '{}': {}",
+                        disk_path, e
+                    );
+                    // Continue anyway - libvirt may still have the domain
+                }
+            }
+        }
+
+        // Remove libvirt domain with nvram
+        println!("  Removing libvirt domain...");
+        let output = global_opts
+            .virsh_command()
+            .args(&["undefine", &domain.name, "--nvram"])
+            .output()
+            .with_context(|| format!("Failed to undefine domain '{}'", domain.name))?;
+
+        if output.status.success() {
+            println!("  VM '{}' removed successfully", domain.name);
+            removed_count += 1;
+        } else {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            eprintln!(
+                "  Failed to remove libvirt domain '{}': {}",
+                domain.name, stderr
+            );
+            error_count += 1;
+        }
+    }
+
+    println!();
+    println!(
+        "Summary: {} VM{} removed, {} error{}",
+        removed_count,
+        if removed_count == 1 { "" } else { "s" },
+        error_count,
+        if error_count == 1 { "" } else { "s" }
+    );
+
+    if error_count > 0 {
+        Err(color_eyre::eyre::eyre!(
+            "Failed to remove {} VM{}",
+            error_count,
+            if error_count == 1 { "" } else { "s" }
+        ))
+    } else {
+        Ok(())
+    }
+}
diff --git a/crates/kit/src/libvirt/run.rs b/crates/kit/src/libvirt/run.rs
index 6afda47..38457dd 100644
--- a/crates/kit/src/libvirt/run.rs
+++ b/crates/kit/src/libvirt/run.rs
@@ -89,12 +89,34 @@ pub struct LibvirtRunOpts {
     /// Directory containing secure boot keys (required for uefi-secure)
     #[clap(long)]
     pub secure_boot_keys: Option<Utf8PathBuf>,
+
+    /// User-defined labels for organizing VMs (comma not allowed in labels)
+    #[clap(long)]
+    pub label: Vec<String>,
+}
+
+impl LibvirtRunOpts {
+    /// Validate that labels don't contain commas
+    fn validate_labels(&self) -> Result<()> {
+        for label in &self.label {
+            if label.contains(',') {
+                return Err(eyre::eyre!(
+                    "Label '{}' contains comma which is not allowed",
+                    label
+                ));
+            }
+        }
+        Ok(())
+    }
 }
 
 /// Execute the libvirt run command
 pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRunOpts) -> Result<()> {
     use crate::images;
 
+    // Validate labels don't contain commas
+    opts.validate_labels()?;
+
     let connect_uri = global_opts.connect.as_ref();
     let lister = match connect_uri {
         Some(uri) => DomainLister::with_connection(uri.clone()),
@@ -657,6 +679,12 @@ fn create_libvirt_domain_from_disk(
         .with_metadata("bootc:ssh-port", &ssh_port.to_string())
         .with_metadata("bootc:image-digest", image_digest);
 
+    // Add labels if specified
+    if !opts.label.is_empty() {
+        let labels = opts.label.join(",");
+        domain_builder = domain_builder.with_metadata("bootc:label", &labels);
+    }
+
     // Add secure boot configuration if enabled
     if let Some(ref sb_config) = secure_boot_config {
         let ovmf_code = crate::libvirt::secureboot::find_ovmf_code_secboot()
diff --git a/crates/kit/src/main.rs b/crates/kit/src/main.rs
index 3429420..c573b19 100644
--- a/crates/kit/src/main.rs
+++ b/crates/kit/src/main.rs
@@ -199,6 +199,9 @@ fn main() -> Result<(), Report> {
                 libvirt::LibvirtSubcommands::Stop(opts) => libvirt::stop::run(&options, opts)?,
                 libvirt::LibvirtSubcommands::Start(opts) => libvirt::start::run(&options, opts)?,
                 libvirt::LibvirtSubcommands::Remove(opts) => libvirt::rm::run(&options, opts)?,
+                libvirt::LibvirtSubcommands::RemoveAll(opts) => {
+                    libvirt::rm_all::run(&options, opts)?
+                }
                 libvirt::LibvirtSubcommands::Inspect(opts) => {
                     libvirt::inspect::run(&options, opts)?
                 }
diff --git a/docs/src/man/bcvk-libvirt-create.md b/docs/src/man/bcvk-libvirt-create.md
deleted file mode 100644
index d4b5920..0000000
--- a/docs/src/man/bcvk-libvirt-create.md
+++ /dev/null
@@ -1,26 +0,0 @@
-# NAME
-
-bcvk-libvirt-create - Create and start domains from uploaded bootc volumes
-
-# SYNOPSIS
-
-**bcvk libvirt create** [*OPTIONS*]
-
-# DESCRIPTION
-
-Create and start domains from uploaded bootc volumes
-
-<!-- BEGIN GENERATED OPTIONS -->
-<!-- END GENERATED OPTIONS -->
-
-# EXAMPLES
-
-TODO: Add practical examples showing how to use this command.
-
-# SEE ALSO
-
-**bcvk**(8)
-
-# VERSION
-
-v0.1.0
diff --git a/docs/src/man/bcvk-libvirt-list.md b/docs/src/man/bcvk-libvirt-list.md
index f73306b..48d8129 100644
--- a/docs/src/man/bcvk-libvirt-list.md
+++ b/docs/src/man/bcvk-libvirt-list.md
@@ -23,6 +23,10 @@ List available bootc volumes with metadata
 
     Show all domains including stopped ones
 
+**--label**=*LABEL*
+
+    Filter domains by label
+
 <!-- END GENERATED OPTIONS -->
 
 # EXAMPLES
diff --git a/docs/src/man/bcvk-libvirt-run.md b/docs/src/man/bcvk-libvirt-run.md
index 92624ca..b2ffe8a 100644
--- a/docs/src/man/bcvk-libvirt-run.md
+++ b/docs/src/man/bcvk-libvirt-run.md
@@ -102,6 +102,10 @@ Run a bootable container as a persistent VM
 
     Directory containing secure boot keys (required for uefi-secure)
 
+**--label**=*LABEL*
+
+    User-defined labels for organizing VMs (comma not allowed in labels)
+
 <!-- END GENERATED OPTIONS -->
 
 # EXAMPLES