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())?;
@@ -67,8 +73,30 @@ fn main() -> Result<(), Box<dyn Error>> {
                     16
                 } 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,54 @@
 use omloom_contracts::{Error, Limits, MemoryBudget, decode_workspace, workspace as api};
 use prost::Message;
 
+// 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-store/src/disk.rs

@@ -22,7 +22,23 @@ use std::{
 type Properties = BTreeMap<String, Value>;
 type Result<T> = std::result::Result<T, Error>;
 const ROOT: &str = "installation";
-const SCHEMA_VERSION: u64 = 14;
+const SCHEMA_VERSION: u64 = 22;
+const PHYSICAL_TEXT: &[&str] = &["basis", "mounting", "item", "enclosure", "old_item"];
+const PHYSICAL_NUMBERS: &[&str] = &[
+    "material_count",
+    "expected",
+    "x_start",
+    "x_length",
+    "y_start",
+    "y_length",
+    "z_start",
+    "z_length",
+    "max_mass_g",
+    "demand_mw",
+    "capacity_mw",
+    "cooling_mw",
+    "cooling_capacity_mw",
+];
 const MAX_CHILDREN: usize = 2048;
 mod deltas;
 mod inventory;
@@ -374,6 +390,12 @@ impl Store {
         }
         let mut schema = LabelSchema::new_node_id("OmRow");
         schema.add_property(PropertyDef::new("key", PropertyType::String).not_null());
+        for name in PHYSICAL_TEXT {
+            schema.add_property(PropertyDef::new(*name, PropertyType::String));
+        }
+        for name in PHYSICAL_NUMBERS {
+            schema.add_property(PropertyDef::new(*name, PropertyType::Int));
+        }
         for name in ["candidate", "cursor", "snapshot"] {
             schema.add_property(PropertyDef::new(name, PropertyType::String));
         }
@@ -546,6 +568,11 @@ impl Store {
                     .keys()
                     .filter(|key| !current.properties.contains_key(*key))
                     .any(|key| {
+                        if PHYSICAL_TEXT.contains(&key.as_str())
+                            || PHYSICAL_NUMBERS.contains(&key.as_str())
+                        {
+                            return false;
+                        }
                         if [
                             "issuer",
                             "subject",