fix(carrier): C-04 — document hidden vault capacity limit and add 80% mount warning

src/carrier.rs

@@ -27,6 +27,8 @@ use crate::vfs::{is_leak_file_with_custom, SanctumDirEntry, SanctumMetaData};
 
 pub const CARRIER_MAGIC: &[u8; 8] = b"SANCTCAR";
 pub const CARRIER_VERSION: u32 = 1;
+pub const CARRIER_MANIFEST_CAPACITY: usize = CHUNK_SIZE - 64; // 1,048,512 Bytes
+pub const CARRIER_MANIFEST_WARN_THRESHOLD: usize = CARRIER_MANIFEST_CAPACITY * 8 / 10; // 838,809 Bytes (80%, C-04)
 
 /// Manifest für das steganografische Dateisystem innerhalb des Alibi-Carriers (Block 0 und 1, C-02).
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -312,6 +314,15 @@ impl CarrierFsInner {
         Ok(())
     }
 
+    /// Ermittelt die aktuelle Bytegröße des Manifests, die Kapazität und den Füllstand in Prozent (C-04).
+    pub fn manifest_usage(&self) -> (usize, usize, f64) {
+        let len = serde_json::to_vec(&self.manifest)
+            .map(|v| v.len())
+            .unwrap_or(0);
+        let pct = (len as f64 / CARRIER_MANIFEST_CAPACITY as f64) * 100.0;
+        (len, CARRIER_MANIFEST_CAPACITY, pct)
+    }
+
     pub fn save_manifest(&mut self) -> Result<()> {
         self.manifest_save_count += 1;
         self.manifest_dirty = false;
@@ -322,18 +333,20 @@ impl CarrierFsInner {
             .unwrap_or(0);
         self.manifest.manifest_generation += 1;
         let manifest_bytes = serde_json::to_vec(&self.manifest)?;
-        if manifest_bytes.len() > (crate::crypto::CHUNK_SIZE - 64) {
+        if manifest_bytes.len() > CARRIER_MANIFEST_CAPACITY {
             bail!(
-                "Carrier-Manifest überschreitet die maximale Blockgröße ({} > {} Bytes).",
+                "Carrier-Manifest überschreitet die maximale Blockgröße ({} > {} Bytes). Empfohlene Obergrenze ca. 7.000 Dateien/Verzeichnisse beachten.",
                 manifest_bytes.len(),
-                crate::crypto::CHUNK_SIZE - 64
+                CARRIER_MANIFEST_CAPACITY
             );
         }
-        if manifest_bytes.len() > 800_000 {
+        if manifest_bytes.len() >= CARRIER_MANIFEST_WARN_THRESHOLD {
+            let pct = (manifest_bytes.len() * 100) / CARRIER_MANIFEST_CAPACITY;
             warn!(
-                "Carrier-Manifest erreicht 80% der Blockkapazität ({}/{} Bytes)",
+                "Warnung (C-04): Hidden-Vault Manifest zu {}% gefüllt ({}/{} Bytes). Empfohlene Obergrenze beachten (~7.000 Dateien/Verzeichnisse).",
+                pct,
                 manifest_bytes.len(),
-                crate::crypto::CHUNK_SIZE - 64
+                CARRIER_MANIFEST_CAPACITY
             );
         }
 
@@ -515,6 +528,19 @@ impl CarrierFs {
         // Rückwärtskompatibilität zu v0.8.0-Containern: Block 1 als redundante Manifest-Kopie reservieren
         manifest.free_blocks.retain(|&b| b >= 2);
 
+        // C-04: Warnung bei Füllstand über 80% beim Mounten
+        if let Ok(manifest_bytes) = serde_json::to_vec(&manifest) {
+            if manifest_bytes.len() >= CARRIER_MANIFEST_WARN_THRESHOLD {
+                let pct = (manifest_bytes.len() * 100) / CARRIER_MANIFEST_CAPACITY;
+                warn!(
+                    "Warnung (C-04): Hidden-Vault Manifest zu {}% gefüllt ({}/{} Bytes). Empfohlene Obergrenze beachten (~7.000 Dateien/Verzeichnisse).",
+                    pct,
+                    manifest_bytes.len(),
+                    CARRIER_MANIFEST_CAPACITY
+                );
+            }
+        }
+
         let now = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .map(|d| d.as_secs())
@@ -581,6 +607,11 @@ impl CarrierFs {
         inner.manifest_dirty
     }
 
+    pub fn manifest_usage(&self) -> (usize, usize, f64) {
+        let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
+        inner.manifest_usage()
+    }
+
     pub fn leak_counter(&self) -> Arc<AtomicU64> {
         let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
         inner.leak_counter.clone()

src/mount.rs

@@ -422,6 +422,22 @@ pub async fn mount_container(
         if enable_tray {
             println!("  • System-Tray:  Icon aktiv (Rechtsklick für Explorer/Trennen)");
         }
+        if vault_id == 1 {
+            if let Some((len, cap, pct)) = fs_clone.carrier_manifest_usage() {
+                if len >= crate::carrier::CARRIER_MANIFEST_WARN_THRESHOLD {
+                    println!(
+                        "  {} Warnung (C-04): Hidden-Vault Manifest zu {:.1}% gefüllt ({}/{} Bytes).",
+                        ui::yellow("[!]"),
+                        pct,
+                        len,
+                        cap
+                    );
+                    println!(
+                        "      Empfohlene Obergrenze beachten: ca. 7.000 Dateien/Verzeichnisse im Hidden Vault."
+                    );
+                }
+            }
+        }
         println!();
         #[cfg(windows)]
         println!(

src/vfs.rs

@@ -795,6 +795,10 @@ impl SanctumFs {
         Ok(())
     }
 
+    pub fn carrier_manifest_usage(&self) -> Option<(usize, usize, f64)> {
+        self.carrier_fs.as_ref().map(|cfs| cfs.manifest_usage())
+    }
+
     pub fn leak_count(&self) -> u64 {
         self.leak_counter().load(Ordering::Relaxed)
     }