feat!: plan racks, cabling and replacements

README.md

@@ -38,6 +38,9 @@ including bounded quantities, model alternatives and supported exclusions,
 then be refined without changing their identity.
 The workspace can [check recorded requirements](docs/inventory.md#recorded-requirements)
 against permitted current facts, preserving missing, stale and conflicting evidence.
+It includes [physical planning](docs/inventory.md#physical-plans-and-cable-ends) with exact
+rack elevations, cable ends, material requirements, reservations and reviewed
+component replacement. Manual results remain separate from verified service health.
 
 ## License
 

crates/omloom-contracts/build.rs

@@ -23,6 +23,12 @@ fn main() -> Result<(), Box<dyn Error>> {
         .boxed(".omloom.workspace.v1.Reply.result.detail")
         .boxed(".omloom.workspace.v1.Reply.result.vm_placement_review")
         .boxed(".omloom.workspace.v1.HostImport.report")
+        // Keep the request stack bound; allocate this volume only for an explicit coverage assertion.
+        .boxed(".omloom.workspace.v1.PhysicalDefinition.occupancy_coverage")
+        .boxed(".omloom.workspace.v1.PhysicalDefinition.rack_grid")
+        .boxed(".omloom.workspace.v1.PhysicalDefinition.clearance")
+        .boxed(".omloom.workspace.v1.PhysicalMaterial.physical")
+        .boxed(".omloom.workspace.v1.PhysicalReplacement.feedback")
         .file_descriptor_set_path(&descriptor)
         .compile_protos(&[workspace], &["../../proto"])?;
     let set = FileDescriptorSet::decode(fs::read(descriptor)?.as_slice())?;
@@ -65,10 +71,36 @@ fn main() -> Result<(), Box<dyn Error>> {
                     && matches!(field.name(), "candidates" | "excluded")
                 {
                     16
+                } else if message.name() == "PowerPathRequirement"
+                    && matches!(field.name(), "sources" | "boundaries")
+                {
+                    8
                 } else if (message.name() == "EvaluateRequirements" && field.name() == "nodes")
                     || (message.name() == "RequirementGroup" && field.name() == "members")
+                    || (message.name() == "PhysicalPlan" && field.name() == "steps")
+                    || (message.name() == "PhysicalView" && field.name() == "definitions")
+                    || (message.name() == "PhysicalCompletion"
+                        && matches!(field.name(), "completed_steps" | "not_performed_steps"))
+                    || (message.name() == "PhysicalPlan" && field.name() == "materials")
+                    || (message.name() == "PhysicalMaterial" && field.name() == "allocations")
+                    || (message.name() == "PhysicalReplacement" && field.name() == "endpoints")
+                    || (message.name() == "PhysicalEndpointMappings" && field.name() == "pairs")
+                    || (message.name() == "PhysicalCableEnd" && field.name() == "channels")
+                    || (message.name() == "PhysicalChannelSet" && field.name() == "channels")
+                    || (message.name() == "PhysicalDefinition" && field.name() == "channels")
                 {
                     64
+                } else if message.name() == "PhysicalMaterial" && field.name() == "specifications" {
+                    12
+                } else if message.name() == "PhysicalView"
+                    && matches!(
+                        field.name(),
+                        "occupancy" | "plans" | "positions" | "replacement_quality"
+                    )
+                {
+                    25
+                } else if message.name() == "PhysicalView" && field.name() == "items" {
+                    256
                 } else {
                     0
                 }

crates/omloom-contracts/src/equipment.rs

@@ -221,29 +221,13 @@ fn identity(value: &Option<EquipmentReference>) -> (&str, &str, &str) {
         None => ("", "", ""),
     }
 }
-/// One bounded semantic encoding for retries, changed-only storage and CSV.
-/// Candidate/exclusion order is irrelevant; source and interpretation basis are not.
-pub fn encode(value: &EquipmentClaim) -> Result<Vec<u8>, Error> {
+/// Normalize an owned bounded claim for changed-only storage and returned plans.
+pub fn canonicalize(value: &mut EquipmentClaim) -> Result<(), Error> {
     validate(value)?;
-    let canonical = match &value.assertion {
-        Some(equipment_claim::Assertion::Quantity(q)) => {
-            q.scale == 0
-                || q.lower.is_some_and(|n| n % 10 != 0)
-                || q.upper.is_some_and(|n| n % 10 != 0)
-        }
-        Some(equipment_claim::Assertion::Alternatives(v)) => {
-            v.candidates.is_sorted_by(|a, b| {
-                (&a.value, identity(&a.reference)) <= (&b.value, identity(&b.reference))
-            }) && v.excluded.is_sorted_by(|a, b| {
-                (&a.value, identity(&a.reference)) <= (&b.value, identity(&b.reference))
-            })
-        }
-        _ => true,
-    };
-    if canonical {
-        return Ok(value.encode_to_vec());
-    }
-    let mut value = value.clone();
+    canonicalize_validated(value);
+    Ok(())
+}
+fn canonicalize_validated(value: &mut EquipmentClaim) {
     if let Some(equipment_claim::Assertion::Quantity(q)) = &mut value.assertion {
         while q.scale > 0
             && q.lower.is_none_or(|n| n % 10 == 0)
@@ -266,6 +250,31 @@ pub fn encode(value: &EquipmentClaim) -> Result<Vec<u8>, Error> {
             (&a.value, identity(&a.reference)).cmp(&(&b.value, identity(&b.reference)))
         });
     }
+}
+/// One bounded semantic encoding for retries, changed-only storage and CSV.
+/// Candidate/exclusion order is irrelevant; source and interpretation basis are not.
+pub fn encode(value: &EquipmentClaim) -> Result<Vec<u8>, Error> {
+    validate(value)?;
+    let canonical = match &value.assertion {
+        Some(equipment_claim::Assertion::Quantity(q)) => {
+            q.scale == 0
+                || q.lower.is_some_and(|n| n % 10 != 0)
+                || q.upper.is_some_and(|n| n % 10 != 0)
+        }
+        Some(equipment_claim::Assertion::Alternatives(v)) => {
+            v.candidates.is_sorted_by(|a, b| {
+                (&a.value, identity(&a.reference)) <= (&b.value, identity(&b.reference))
+            }) && v.excluded.is_sorted_by(|a, b| {
+                (&a.value, identity(&a.reference)) <= (&b.value, identity(&b.reference))
+            })
+        }
+        _ => true,
+    };
+    if canonical {
+        return Ok(value.encode_to_vec());
+    }
+    let mut value = value.clone();
+    canonicalize_validated(&mut value);
     Ok(value.encode_to_vec())
 }
 

crates/omloom-contracts/src/equipment/tests.rs

@@ -1,4 +1,28 @@
 use super::*;
+
+// Owned plans and the persisted encoding must share normalization, including retry order and fixed-point spelling.
+#[test]
+fn owned_claim_canonicalization_matches_encoding_and_is_idempotent() {
+    let mut value = possible();
+    let encoded = encode(&value).expect("valid claim");
+    canonicalize(&mut value).expect("valid owned claim");
+    assert_eq!(value.encode_to_vec(), encoded);
+    let previous = value.clone();
+    canonicalize(&mut value).expect("already canonical claim");
+    assert_eq!(value, previous);
+    let mut quantity = EquipmentClaim {
+        basis: "Recorded physical measurement".into(),
+        assertion: Some(equipment_claim::Assertion::Quantity(QuantityRange {
+            lower: Some(1200),
+            upper: None,
+            scale: 2,
+            unit: "mm".into(),
+        })),
+    };
+    let encoded = encode(&quantity).expect("valid measurement");
+    canonicalize(&mut quantity).expect("owned measurement");
+    assert_eq!(quantity.encode_to_vec(), encoded);
+}
 fn possible() -> EquipmentClaim {
     EquipmentClaim {
         basis: "Front label and visible bays".into(),

crates/omloom-contracts/src/ids.rs

@@ -52,6 +52,7 @@ id!(SourceId);
 id!(AuthorityId);
 id!(RelationId);
 id!(OperationId);
+id!(PlanId);
 id!(ScanId);
 id!(TrustId);
 id!(CredentialBindingId);

crates/omloom-contracts/tests/workspace.rs

@@ -1,6 +1,91 @@
 use omloom_contracts::{Error, Limits, MemoryBudget, decode_workspace, workspace as api};
 use prost::Message;
 
+// The evaluator's eight-reference bound must reject oversized frames before decoded allocation.
+#[test]
+fn power_path_reference_counts_are_bounded_before_decode() {
+    for sources in [true, false] {
+        for count in [8, 9] {
+            let refs = vec![Default::default(); count];
+            let mut paths = api::PowerPathRequirement::default();
+            if sources {
+                paths.sources = refs;
+            } else {
+                paths.boundaries = refs;
+            }
+            let bytes = api::Request {
+                command: Some(api::request::Command::EvaluateRequirements(
+                    api::EvaluateRequirements {
+                        nodes: vec![api::RequirementNode {
+                            expression: Some(api::requirement_node::Expression::PowerPaths(paths)),
+                        }],
+                        ..Default::default()
+                    },
+                )),
+                ..Default::default()
+            }
+            .encode_to_vec();
+            let budget = MemoryBudget::new(16 * 1_048_576);
+            let decoded = decode_workspace(&bytes, Limits::default(), &budget);
+            if count == 9 {
+                assert!(matches!(decoded, Err(Error::Limit)));
+            } else {
+                assert!(decoded.is_ok());
+            }
+            drop(decoded);
+            assert_eq!(budget.used(), 0);
+        }
+    }
+}
+
+// Physical wire containers enforce repeated bounds before prost allocates their vectors.
+#[test]
+fn physical_channels_and_endpoint_maps_are_bounded_before_decode() {
+    let budget = MemoryBudget::new(16 * 1_048_576);
+    let channels = api::Request {
+        working: None,
+        command: Some(api::request::Command::Physical(api::Physical {
+            action: Some(api::physical::Action::Define(api::PhysicalDefinitionEdit {
+                definition: Some(api::PhysicalDefinition {
+                    channels: vec![1; 65],
+                    ..Default::default()
+                }),
+            })),
+        })),
+    }
+    .encode_to_vec();
+    assert!(matches!(
+        decode_workspace(&channels, Limits::default(), &budget),
+        Err(Error::Limit)
+    ));
+    assert_eq!(budget.used(), 0);
+    let mappings = api::Request {
+        working: None,
+        command: Some(api::request::Command::Physical(api::Physical {
+            action: Some(api::physical::Action::Save(api::PhysicalSave {
+                plan: Some(api::PhysicalPlan {
+                    steps: vec![api::PhysicalStep {
+                        action: Some(api::physical_step::Action::Replacement(
+                            api::PhysicalReplacement {
+                                endpoints: vec![Default::default(); 65],
+                                ..Default::default()
+                            },
+                        )),
+                        ..Default::default()
+                    }],
+                    ..Default::default()
+                }),
+            })),
+        })),
+    }
+    .encode_to_vec();
+    assert!(matches!(
+        decode_workspace(&mappings, Limits::default(), &budget),
+        Err(Error::Limit)
+    ));
+    assert_eq!(budget.used(), 0);
+}
+
 // Omitted wire input cannot implicitly request an exclusive allocation.
 #[test]
 fn network_sharing_requires_an_explicit_mechanism() {

crates/omloom-observe/src/command.rs

@@ -101,7 +101,7 @@ impl Runner {
             };
             let result = match timeout_at(deadline, work).await {
                 Ok(result) => result,
-                Err(_) => Err("Command deadline exceeded".into()),
+                Err(_) => Err(format!("Command deadline exceeded ({executable})")),
             };
             if result.is_err() && child.id().is_some() {
                 child

crates/omloom-observe/src/command/tests.rs

@@ -119,9 +119,11 @@ async fn deadline_terminates_the_owned_child() {
         .await;
     #[cfg(not(windows))]
     let result = runner.run("/bin/sleep", &["5"]).await;
-    assert_eq!(
-        result.err().expect("deadline failure"),
-        "Command deadline exceeded"
-    );
+    let message = result.err().expect("deadline failure");
+    assert!(message.starts_with("Command deadline exceeded"));
+    #[cfg(windows)]
+    assert!(message.contains("cmd.exe"));
+    #[cfg(not(windows))]
+    assert!(message.contains("/bin/sleep"));
     assert_eq!(runner.remaining, initial);
 }

crates/omloom-observe/src/main.rs

@@ -76,7 +76,9 @@ fn add(report: &mut api::HostReport, value: api::HostFinding) -> Result<()> {
 
 async fn collect() -> Result<api::HostReport> {
     let mut runner = command::Runner::new();
-    let identity = native::identity(&mut runner).await?;
+    let identity = native::identity(&mut runner)
+        .await
+        .map_err(|error| format!("Initial host identity unavailable: {error}"))?;
     let native::Identity {
         platform,
         source,
@@ -128,7 +130,9 @@ async fn collect() -> Result<api::HostReport> {
     });
     native::collect(&mut runner, &mut report).await?;
     runtime::collect(&mut runner, &mut report).await?;
-    let after = native::identity(&mut runner).await?;
+    let after = native::identity(&mut runner)
+        .await
+        .map_err(|error| format!("Final host identity unavailable: {error}"))?;
     check_identity(&source, &boot, &after.source, &after.boot)?;
     if report.findings.first().and_then(|v| v.identity.first()) != after.hardware.as_ref() {
         return Err("Hardware evidence changed during collection; output not written".into());
@@ -203,6 +207,20 @@ fn save(path: &Path, bytes: &[u8]) -> Result<()> {
         .map_err(|e| format!("Report directory sync failed: {e}"))?;
     Ok(())
 }
+fn finish_collection(report: Result<api::HostReport>, path: &Path) -> Result<()> {
+    let report = match report {
+        Ok(report) => report,
+        Err(reason) => {
+            println!("Collection unavailable: {reason}. No report was written.");
+            return Ok(());
+        }
+    };
+    let bytes = encode(report)?;
+    save(path, &bytes)?;
+    println!("Report written. Import it in Omloom to review selected current facts.");
+    Ok(())
+}
+
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
     let args: Vec<_> = std::env::args_os().skip(1).collect();
@@ -245,9 +263,5 @@ async fn main() -> Result<()> {
         }
         return Ok(());
     }
-    let report = collect().await?;
-    let bytes = encode(report)?;
-    save(Path::new(&args[1]), &bytes)?;
-    println!("Report written. Import it in Omloom to review selected current facts.");
-    Ok(())
+    finish_collection(collect().await, Path::new(&args[1]))
 }