chore(consistency): sync task status from DB [auto]

Updated by fix-consistency on 2026-05-07:
  - update .custodian-brief.md for open-cmis-tck

src/open_cmis_tck/preflight.py

@@ -117,12 +117,43 @@ def run(context: dict[str, Any]) -> dict[str, Any]:
         }
 
     facts["json_detected"] = True
-    facts.update(_repository_facts(parsed))
+    repository_facts = _repository_facts(parsed, context)
+    facts.update(repository_facts)
+    unsupported = [
+        item
+        for item in repository_facts.get("capability_posture", [])
+        if item.get("status") == "unsupported"
+    ]
+    expected_gaps = [
+        item
+        for item in repository_facts.get("capability_posture", [])
+        if item.get("status") == "expected_gap"
+    ]
+    if unsupported:
+        return {
+            "result": "fail",
+            "observations": [
+                "CMIS Browser Binding endpoint is reachable, but declared capabilities are not supported by repository capability flags.",
+                "Unsupported declared requirements: "
+                + ", ".join(item["requirement_ref"] for item in unsupported)
+                + ".",
+            ],
+            "facts": facts,
+            "artifact_refs": artifact_refs,
+        }
+
+    observations = [
+        "CMIS Browser Binding endpoint is reachable and returned parseable JSON."
+    ]
+    if expected_gaps:
+        observations.append(
+            "Unsupported optional capabilities were accepted as known gaps: "
+            + ", ".join(item["requirement_ref"] for item in expected_gaps)
+            + "."
+        )
     return {
         "result": "pass",
-        "observations": [
-            "CMIS Browser Binding endpoint is reachable and returned parseable JSON."
-        ],
+        "observations": observations,
         "facts": facts,
         "artifact_refs": artifact_refs,
     }
@@ -150,29 +181,40 @@ def _parse_json(body: bytes) -> Any:
         return None
 
 
-def _repository_facts(value: Any) -> dict[str, Any]:
+def _repository_facts(value: Any, context: dict[str, Any]) -> dict[str, Any]:
     if not isinstance(value, dict):
         return {"repository_shape": "unknown"}
 
     if "repositoryId" in value:
+        repository_id = str(value["repositoryId"])
         return {
             "repository_shape": "single-repository-info",
-            "repository_ids": [value["repositoryId"]],
+            "repository_ids": [repository_id],
+            "selected_repository_id": repository_id,
             "cmis_version_supported": value.get("cmisVersionSupported"),
             "capabilities_present": isinstance(value.get("capabilities"), dict),
+            "capability_flags": _capability_flags(value),
+            "capability_posture": _capability_posture(value, context),
         }
 
-    repository_ids = []
+    repositories: dict[str, dict[str, Any]] = {}
     for key, child in value.items():
         if isinstance(child, dict) and (
             "repositoryId" in child or "repositoryName" in child
         ):
-            repository_ids.append(str(child.get("repositoryId", key)))
+            repositories[str(child.get("repositoryId", key))] = child
 
-    if repository_ids:
+    if repositories:
+        selected_repository_id = _selected_repository_id(repositories, context)
+        selected_repository = repositories[selected_repository_id]
         return {
             "repository_shape": "repository-map",
-            "repository_ids": repository_ids,
+            "repository_ids": sorted(repositories),
+            "selected_repository_id": selected_repository_id,
+            "cmis_version_supported": selected_repository.get("cmisVersionSupported"),
+            "capabilities_present": isinstance(selected_repository.get("capabilities"), dict),
+            "capability_flags": _capability_flags(selected_repository),
+            "capability_posture": _capability_posture(selected_repository, context),
         }
 
     return {
@@ -181,6 +223,99 @@ def _repository_facts(value: Any) -> dict[str, Any]:
     }
 
 
+def _selected_repository_id(
+    repositories: dict[str, dict[str, Any]],
+    context: dict[str, Any],
+) -> str:
+    configured = _opencmis_policy(context).get("repository_id")
+    if isinstance(configured, str) and configured in repositories:
+        return configured
+    return sorted(repositories)[0]
+
+
+def _capability_flags(repository_info: dict[str, Any]) -> dict[str, Any]:
+    capabilities = repository_info.get("capabilities", {})
+    return dict(capabilities) if isinstance(capabilities, dict) else {}
+
+
+def _capability_posture(
+    repository_info: dict[str, Any],
+    context: dict[str, Any],
+) -> list[dict[str, Any]]:
+    target = context["target_profile"]
+    declared = set(target.get("declared_capabilities", []))
+    known_gap_refs = {
+        requirement_ref: gap["id"]
+        for gap in target.get("known_gaps", [])
+        for requirement_ref in gap.get("requirement_refs", [])
+    }
+    refs = sorted(declared | set(known_gap_refs))
+    flags = _capability_flags(repository_info)
+    posture = []
+    for requirement_ref in refs:
+        support = _requirement_support(requirement_ref, flags)
+        if support is True:
+            status = "supported"
+        elif support is False and requirement_ref in known_gap_refs:
+            status = "expected_gap"
+        elif support is False:
+            status = "unsupported"
+        else:
+            status = "unknown"
+        posture.append(
+            {
+                "requirement_ref": requirement_ref,
+                "status": status,
+                "known_gap_ref": known_gap_refs.get(requirement_ref),
+                "flag_refs": _flag_refs(requirement_ref),
+            }
+        )
+    return posture
+
+
+def _requirement_support(requirement_ref: str, flags: dict[str, Any]) -> bool | None:
+    if requirement_ref == "cmis.repository-info":
+        return True
+    flag_refs = _flag_refs(requirement_ref)
+    if not flag_refs:
+        return None
+    values = [flags[key] for key in flag_refs if key in flags]
+    if not values:
+        return None
+    return any(_flag_supports(value) for value in values)
+
+
+def _flag_refs(requirement_ref: str) -> list[str]:
+    return {
+        "cmis.query": ["capabilityQuery"],
+        "cmis.acl": ["capabilityACL"],
+        "cmis.navigation-services": [
+            "capabilityGetDescendants",
+            "capabilityGetFolderTree",
+        ],
+        "cmis.relationships": ["capabilityJoin"],
+        "cmis.change-log": ["capabilityChanges"],
+        "cmis.versioning": [
+            "capabilityVersionSpecificFiling",
+            "capabilityPWCSearchable",
+            "capabilityPWCUpdatable",
+        ],
+    }.get(requirement_ref, [])
+
+
+def _flag_supports(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.lower() not in {"", "false", "none", "no"}
+    return value is not None
+
+
+def _opencmis_policy(context: dict[str, Any]) -> dict[str, Any]:
+    policy = context["assessment_profile"].get("runtime_policy", {}).get("opencmis_tck", {})
+    return policy if isinstance(policy, dict) else {}
+
+
 def _write_response_artifacts(
     context: dict[str, Any],
     status_code: int,