hive-c0re: an unreadable capabilities file denies ManageRootAgent mounts

set_nspawn_flags propagated has_cap's error, so one corrupt
capabilities.json failed every agent's Start, spawn and Swap. It now
goes through holds_manage_root_agent, which logs the error (agent and
file) and treats the capability as absent: the agent starts without the
cross-agent, /applied and /meta mounts. caps_for/has_cap take the file
path so that seam is testable against a tempfile.

- meta.rs: a comment at the render_flake reads records why they
  propagate (an empty tool-groups map renders toolGroups = null, i.e.
  AGENT_DEFAULT, which fails open for narrower explicit entries).
- capabilities::read doc: states when set_caps/remove_agent rewrite
  the file instead of saying remove_agent repairs it.
- set/remove corrupt-file tests assert ErrorKind::InvalidData.

hive-c0re/src/agent_config/capabilities.rs

@@ -66,8 +66,9 @@ fn prune_unknown(map: &mut BTreeMap<String, Vec<String>>) -> bool {
 /// that exists but can't be read or parsed is an error. Any entry that
 /// isn't a recognised [`Capability`] is dropped (with a `warn!`) from
 /// what's returned — a stale or typo'd name is never honoured — but
-/// `read` itself never writes; the on-disk file only gets repaired the
-/// next time something calls `set_caps`/`remove_agent` anyway.
+/// `read` itself never writes. Unknown names stay on disk until the next
+/// write: `set_caps` always rewrites the file, `remove_agent` only when
+/// the agent had an entry.
 pub fn read() -> std::io::Result<BTreeMap<String, Vec<String>>> {
     read_from(&capabilities_path())
 }
@@ -78,16 +79,21 @@ fn read_from(path: &Path) -> std::io::Result<BTreeMap<String, Vec<String>>> {
     Ok(map)
 }
 
-/// Look up the configured capabilities for one agent. Returns an empty
-/// vec when the agent has no entry. Errors as [`read`] does.
-pub fn caps_for(name: &str) -> std::io::Result<Vec<String>> {
-    Ok(read()?.get(name).cloned().unwrap_or_default())
+/// Look up the configured capabilities for one agent in the file at
+/// `path` (normally [`capabilities_path`]). Returns an empty vec when
+/// the agent has no entry. Errors as [`read`] does.
+pub fn caps_for(path: &Path, name: &str) -> std::io::Result<Vec<String>> {
+    Ok(read_from(path)?.get(name).cloned().unwrap_or_default())
 }
 
-/// Check whether an agent holds a specific capability. Errors as
-/// [`read`] does.
-pub fn has_cap(name: &str, cap: hive_sh4re::permissions::Capability) -> std::io::Result<bool> {
-    Ok(caps_for(name)?
+/// Check whether an agent holds a specific capability, per the file at
+/// `path` (normally [`capabilities_path`]). Errors as [`read`] does.
+pub fn has_cap(
+    path: &Path,
+    name: &str,
+    cap: hive_sh4re::permissions::Capability,
+) -> std::io::Result<bool> {
+    Ok(caps_for(path, name)?
         .iter()
         .any(|s| s.eq_ignore_ascii_case(<&str>::from(cap))))
 }
@@ -154,7 +160,7 @@ fn remove_agent_at(path: &Path, name: &str) -> std::io::Result<()> {
 mod tests {
     use super::*;
 
-    // `read`/`set_caps`/`remove_agent` shell out to `crate::paths::meta_root`,
+    // `read`/`set_caps`/`remove_agent` call `crate::paths::meta_root`,
     // which is hardcoded to `/var/lib/hyperhive` (no test override) — so
     // these tests pin the pure decision logic (`prune_unknown`,
     // `apply_known_caps`) against in-memory maps, and the file handling
@@ -178,15 +184,18 @@ mod tests {
     #[test]
     fn set_caps_leaves_a_corrupt_file_untouched() {
         let (_dir, path) = corrupt_file();
-        set_caps_at(&path, "ruth", &["manage_root_agent".to_owned()])
+        let err = set_caps_at(&path, "ruth", &["manage_root_agent".to_owned()])
             .expect_err("a corrupt file must not be overwritten");
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
         assert_eq!(std::fs::read(&path).expect("read"), TRUNCATED.as_bytes());
     }
 
     #[test]
     fn remove_agent_leaves_a_corrupt_file_untouched() {
         let (_dir, path) = corrupt_file();
-        remove_agent_at(&path, "atlas").expect_err("a corrupt file must not be overwritten");
+        let err =
+            remove_agent_at(&path, "atlas").expect_err("a corrupt file must not be overwritten");
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
         assert_eq!(std::fs::read(&path).expect("read"), TRUNCATED.as_bytes());
     }
 

hive-c0re/src/agent_config/tool_groups.rs

@@ -127,15 +127,21 @@ mod tests {
     #[test]
     fn set_groups_leaves_a_corrupt_file_untouched() {
         let (_dir, path) = corrupt_file();
-        set_groups_at(&path, "ruth", &["messaging".to_owned()])
+        let err = set_groups_at(&path, "ruth", &["messaging".to_owned()])
             .expect_err("a corrupt file must not be overwritten");
+        let kind = err
+            .downcast_ref::<std::io::Error>()
+            .map(std::io::Error::kind);
+        assert_eq!(kind, Some(std::io::ErrorKind::InvalidData));
         assert_eq!(std::fs::read(&path).expect("read"), TRUNCATED.as_bytes());
     }
 
     #[test]
     fn remove_agent_leaves_a_corrupt_file_untouched() {
         let (_dir, path) = corrupt_file();
-        remove_agent_at(&path, "alice").expect_err("a corrupt file must not be overwritten");
+        let err =
+            remove_agent_at(&path, "alice").expect_err("a corrupt file must not be overwritten");
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
         assert_eq!(std::fs::read(&path).expect("read"), TRUNCATED.as_bytes());
     }