fix(cost): reject unsupported cache and storage evidence combinations

Author: zzylol

crates/asap-aware-mapping/src/physical_plan_cost_model.rs

@@ -156,6 +156,16 @@ impl<'a> PhysicalPlanCostModel<'a> {
         target: &TargetSubDAG<'_>,
     ) -> Result<PhysicalPlanComparison, AnalyticalCostError> {
         let (snapshot, raw) = self.target_evidence(target)?;
+        // Aggregate cache hit ratios do not identify which independently rounded
+        // extents issue requests. Do not mix cache-adjusted bytes/CPU with
+        // uncached request counts until cache-aware extent evidence is available.
+        if snapshot.storage_io.is_some()
+            && matches!(&snapshot.cache_profile, CacheProfile::Evidence(_))
+        {
+            return Err(AnalyticalCostError::InvalidCacheEvidence(
+                "storage operation costs require an explicit no-cache profile; cache-aware extent evidence is unavailable",
+            ));
+        }
         let scope = &snapshot.scope;
         let evidence = QueryEvidence {
             provider: self.provider,

crates/devtools/src/bin/dag_export.rs

@@ -1675,6 +1675,18 @@ mod tests {
             .as_ref()
             .unwrap()
             .contains(STORAGE_IO_MODEL_VERSION));
+        assert_eq!(selected.cache_profile.as_deref(), Some("no-cache-v1"));
+        for name in ["result_cache_hit_ratio", "buffer_cache_hit_ratio"] {
+            assert_eq!(
+                selected
+                    .inputs
+                    .iter()
+                    .find(|term| term.name == name)
+                    .unwrap()
+                    .value,
+                0.0
+            );
+        }
         assert_eq!(
             selected.evidence_version.as_deref(),
             Some("test-evidence-v1")
@@ -1693,6 +1705,24 @@ mod tests {
         let (baseline, selected, _) = model.annotations(&candidate, &root);
         assert_eq!(baseline.value, Some(160.0));
         assert_eq!(selected.value, Some(10.0));
+        // Aggregate cache hit assumptions cannot locate cached extents or
+        // reconstruct independently rounded physical storage requests.
+        let mut cached = serde_json::to_value(&requests_only).unwrap();
+        cached["targets"][0]["scope"]["cache_profile"] = serde_json::json!({
+            "profile": "evidence", "version": "cached-with-storage-v1",
+            "distinct_evaluations": 1, "repeated_identical_evaluations": 9,
+            "result_cache": {"working_set_bytes": 100, "capacity_bytes": 100},
+            "buffer_cache": {"working_set_bytes": 100, "capacity_bytes": 100},
+            "result_invalidation_ratio": null,
+        });
+        let cached = parse_planner_cost_document(&cached.to_string()).unwrap();
+        let cached_model = ExportPlannerCostModel { document: &cached };
+        assert!(cached_model.candidate_cost(&candidate, &target).is_none());
+        assert!(cached_model
+            .annotations(&candidate, &root)
+            .0
+            .value
+            .is_none());
         document
             .storage_io
             .as_mut()

crates/types/src/resources.rs

@@ -11,8 +11,8 @@ pub mod cpu;
 pub mod measurement;
 pub mod physical;
 pub mod storage;
-pub use storage::StorageResources;
 pub use cache::{CacheCapacityEvidence, CacheEvidence, CacheProfile};
+pub use storage::StorageResources;
 
 pub use cpu::{MeasuredCpu, ModeledCpu};
 pub use measurement::Measurement;

docs/developer_docs/storage-operation-costs.md

@@ -72,8 +72,13 @@ Missing entries, expired/future evidence, incompatible node snapshots, zero
 request sizes, invalid calibration, and overflow return typed analytical
 errors. When used by plan ranking/export they make that comparison unavailable.
 This profile extends the physical-plan adapter; the separate summary-maintenance
-lifecycle estimator retains its existing dimensions. Cache behavior is a
-separate model input and is not inferred here.
+lifecycle estimator retains its existing dimensions. Combined physical-plan
+ranking currently supports storage profiles only with an explicit `NoCache`
+profile. `CacheProfile::Evidence` together with storage evidence makes the
+comparison unavailable: aggregate cache hit ratios cannot identify which
+independently rounded extents issue requests. Supporting that combination
+requires cache-aware extent/request evidence; the adapter does not mix
+cache-adjusted bytes and CPU with uncached operation counts.
 
 Verification: