fix: report conditional partition disjointness

Author: morluto

src/jacobian/finite_partition.py

@@ -375,6 +375,15 @@ def invoke(self, request: CapabilityRequest) -> CapabilityResult:
             and not duplicate_case_ids
             and (not require_disjoint or not overlaps)
         )
+        verified_replay_basis = (
+            "authorized checker replayed equality-based coverage and required "
+            "disjointness within the caller-supplied universe"
+            if require_disjoint
+            else (
+                "authorized checker replayed equality-based coverage within the "
+                "caller-supplied universe; disjointness was not required"
+            )
+        )
         return CapabilityResult(
             capability_id=self.descriptor.capability_id,
             capability_version=self.descriptor.version,
@@ -414,9 +423,8 @@ def invoke(self, request: CapabilityRequest) -> CapabilityResult:
                     else CapabilityCompletenessStatus.PARTIAL
                 ),
                 basis=(
-                    "authorized checker replayed equality-based coverage and "
-                    "disjointness within the caller-supplied universe; it did not "
-                    "check external-domain completeness or member/case semantics"
+                    f"{verified_replay_basis}; it did not check external-domain "
+                    "completeness or member/case semantics"
                     if verified
                     else "generator-side membership accounting; not independently checked"
                 ),
@@ -443,9 +451,8 @@ def invoke(self, request: CapabilityRequest) -> CapabilityResult:
             assurance=CapabilityAssurance(
                 level=assurance_level,
                 basis=(
-                    "operator-authorized checker accepted equality-based coverage and "
-                    "disjointness within the caller-supplied universe; external-domain "
-                    "completeness and member/case semantics were not checked"
+                    f"{verified_replay_basis}; external-domain completeness and "
+                    "member/case semantics were not checked"
                     if verified
                     else "partition was proposed and inspected by its generator only"
                 ),
@@ -475,7 +482,7 @@ def _verify(
             scope_digest=scope.manifest.object_digest,
         )
         payload: dict[str, Any] = {
-            "replay": "exact finite membership",
+            "replay": "equality-based finite coverage and conditional disjointness",
             "relation_id": "case.relation.partitions",
             "obligation_uri": claim_uri,
         }

tests/composition/runtime/test_finite_partition_capability.py

@@ -11,7 +11,12 @@
 from jacobian.contracts.results import Arithmetic, Conclusion, Coverage, Method
 
 
-def _request(mode: CapabilityMode, *, missing_last: bool = False) -> CapabilityRequest:
+def _request(
+    mode: CapabilityMode,
+    *,
+    missing_last: bool = False,
+    require_disjoint: bool = True,
+) -> CapabilityRequest:
     return CapabilityRequest(
         capability_id="case.partition.finite",
         mode=mode,
@@ -24,7 +29,7 @@ def _request(mode: CapabilityMode, *, missing_last: bool = False) -> CapabilityR
                     "members": ["1", "3"] if missing_last else ["1", "3", "5"],
                 },
             ],
-            "require_disjoint": True,
+            "require_disjoint": require_disjoint,
         },
     )
 
@@ -78,6 +83,25 @@ def test_finite_partition_contract_and_result_preserve_semantic_boundary(
     assert "member/case semantics" in result.completeness.basis
 
 
+def test_finite_partition_reports_conditional_disjointness_scope(
+    authorized_complete_runtime,
+) -> None:
+    runtime = authorized_complete_runtime
+    request = _request(CapabilityMode.VERIFY, require_disjoint=False)
+    request.input["cases"][1]["members"].append("0")
+
+    result = runtime.core.capabilities.invoke(request)
+
+    assert result.assurance.level is CapabilityAssuranceLevel.VERIFIED
+    assert result.output["overlaps"] == ["0"]
+    assert "disjointness was not required" in result.assurance.basis
+    assert "disjointness was not required" in result.completeness.basis
+    certificate = runtime.core.store.get(result.output["certificate_uri"])
+    assert certificate.payload["payload"]["replay"] == (
+        "equality-based finite coverage and conditional disjointness"
+    )
+
+
 def test_finite_partition_verify_fails_closed_on_incomplete_cases(
     authorized_complete_runtime,
 ) -> None: