ltcai 11.5.2 → 11.7.0

package/latticeai/core/context_builder.py

@@ -1,394 +0,0 @@
-"""
-Context Builder — Knowledge Graph 기반 문서 생성용 컨텍스트 조합 모듈.
-
-retrieve_context_for_generation() 파이프라인:
-  Step 1: Query → Hybrid Search (text + graph + recency)
-  Step 2: Seed nodes → Multi-hop traversal (Document → Project → Concept)
-  Step 3: Top-K 결과를 구조화된 Markdown Context로 변환
-
-**Shared context contract (v9.9.6).** Chat assembles context through
-:class:`lattice_brain.context.ContextAssembler` — budgeted, provenance-carrying,
-with an honest ``context_quality`` signal. Document generation used to build
-its own markdown with no budget and no quality signal, so the same Brain
-answered a chat question and wrote a document under different guarantees.
-
-The rendering stays different on purpose (a document prompt wants structured
-sections, a chat prompt wants terse lines), but the *contract* is now one:
-
-* the same ``approx_tokens`` accounting and an explicit budget,
-* the same ``context_quality_signal`` shape chat reports,
-* a ``trace`` in the assembler's shape (budget / used / sections).
-
-Review 2026-07-27 P1 #5: "같은 Brain이면 같은 품질 계약".
-"""
-
-import re
-from typing import Any, Dict, List
-
-from lattice_brain.context import approx_tokens
-from lattice_brain.graph.retrieval import context_quality_signal, multimodal_signal
-from lattice_brain.self_model import DEFAULT_SUMMARY_TOKENS, summary_for_prompt
-
-_CLEAN_RE = re.compile(r"\s+")
-
-# Approximate-token ceiling for the document-generation context block. Mirrors
-# the chat assembler's default budget so neither path can silently outgrow the
-# other on the same Brain.
-DEFAULT_DOCUMENT_CONTEXT_BUDGET = 2000
-
-# ── Self-Model injection (v11.1.0) ──────────────────────────────────────────
-# What the Brain knows about its owner rides along with the knowledge, so a
-# generated document sounds like the person who asked for it. Three rules keep
-# it from becoming another thing that can go wrong:
-#   1. an empty Self-Model injects *nothing* — no header, no blank section;
-#   2. the block never takes more than half the context budget, so the profile
-#      can never crowd out the knowledge the request is actually about;
-#   3. the returned contract is unchanged — same keys, same
-#      ``context_quality`` shape, one extra trace section only when a block
-#      was really injected.
-SELF_MODEL_SECTION_TITLE = "사용자 프로필"
-SELF_MODEL_TRACE_SOURCE = "self_model"
-SELF_MODEL_SECTION_HEADER = f"### 🙋 {SELF_MODEL_SECTION_TITLE}\n\n"
-
-
-def _clean(text: str, max_len: int = 700) -> str:
-    return _CLEAN_RE.sub(" ", str(text or "")).strip()[:max_len]
-
-
-def _empty_result(query: str, reason: str) -> Dict[str, Any]:
-    quality = context_quality_signal("none", 0, reason=reason)
-    return {
-        "query": query,
-        "context_markdown": "",
-        "sources": [],
-        "stats": {"method": "none", "matches": 0},
-        "context_quality": quality,
-        "trace": {
-            "budget_approx_tokens": DEFAULT_DOCUMENT_CONTEXT_BUDGET,
-            "used_approx_tokens": 0,
-            "sections": [],
-        },
-    }
-
-
-def _fit_to_budget(context_md: str, budget: int) -> tuple:
-    """Trim rendered markdown to ``budget`` approximate tokens.
-
-    Cuts at a section boundary when possible so the prompt never ends inside
-    half an entry, and reports the trim so the trace stays honest.
-    """
-    if budget <= 0 or approx_tokens(context_md) <= budget:
-        return context_md, False
-    limit = budget * 4
-    head = context_md[:limit]
-    boundary = head.rfind("\n### ")
-    if boundary > limit // 3:
-        head = head[:boundary]
-    return head.rstrip(), True
-
-
-def _self_model_budget(budget: int, limit_tokens: int) -> int:
-    """Tokens the profile block may use — never more than half the budget."""
-    if budget <= 0:
-        return limit_tokens
-    return min(limit_tokens, budget // 2)
-
-
-def _self_model_block(
-    kg_store,
-    *,
-    enabled: bool,
-    budget: int,
-    limit_tokens: int,
-    allowed_workspaces,
-) -> str:
-    """Rendered profile section, or ``""`` when there is nothing to inject.
-
-    The section header is charged to the same allowance as the summary, so the
-    *rendered block* — not just its text — honours the ceiling.
-    """
-    allowance = _self_model_budget(budget, limit_tokens) - approx_tokens(
-        SELF_MODEL_SECTION_HEADER
-    )
-    if not enabled or allowance <= 0:
-        return ""
-    summary = summary_for_prompt(
-        kg_store, limit_tokens=allowance, allowed_workspaces=allowed_workspaces
-    )
-    if not summary:
-        return ""
-    return f"{SELF_MODEL_SECTION_HEADER}{summary}"
-
-
-def _with_self_model(block: str, context_md: str) -> str:
-    """Prepend the profile block to rendered knowledge (either may be empty)."""
-    return "\n\n".join(part for part in (block, context_md) if part)
-
-
-def _self_model_trace(block: str) -> List[Dict[str, Any]]:
-    if not block:
-        return []
-    return [{
-        "name": SELF_MODEL_SECTION_TITLE,
-        "source": SELF_MODEL_TRACE_SOURCE,
-        "approx_tokens": approx_tokens(block),
-        "provenance": [],
-    }]
-
-
-def retrieve_context_for_generation(
-    kg_store,
-    query: str,
-    *,
-    max_results: int = 10,
-    max_hops: int = 2,
-    allowed_workspaces=None,
-    include_legacy_global: bool = False,
-    budget: int = DEFAULT_DOCUMENT_CONTEXT_BUDGET,
-    include_self_model: bool = True,
-    self_model_tokens: int = DEFAULT_SUMMARY_TOKENS,
-) -> Dict[str, Any]:
-    """Knowledge Graph에서 문서 생성에 필요한 컨텍스트를 검색·조합한다.
-
-    Returns:
-        {
-            "query": str,
-            "context_markdown": str,   # LLM 프롬프트에 직접 주입할 Markdown
-            "sources": [...],          # 참조된 소스 목록
-            "stats": {...},            # 검색 통계
-            "context_quality": {...},  # chat과 동일한 정직 신호 (v9.9.6)
-            "trace": {...},            # assembler와 동일한 예산/섹션 추적
-        }
-    """
-    query = str(query or "").strip()
-    if not query or not kg_store:
-        return _empty_result(query, "문서 생성 컨텍스트를 조회할 수 없습니다")
-
-    scope_kwargs = (
-        {
-            "allowed_workspaces": allowed_workspaces,
-            "include_legacy_global": include_legacy_global,
-        }
-        if allowed_workspaces is not None
-        else {}
-    )
-    self_model_md = _self_model_block(
-        kg_store,
-        enabled=include_self_model,
-        budget=budget,
-        limit_tokens=self_model_tokens,
-        allowed_workspaces=allowed_workspaces,
-    )
-    # The profile's tokens come out of the same budget, so injecting it can
-    # never push the assembled context over the ceiling the caller asked for.
-    # The blank line that joins the two blocks is counted too — otherwise the
-    # assembled total lands one token over a tight budget.
-    knowledge_budget = budget
-    if self_model_md:
-        knowledge_budget -= approx_tokens(f"{self_model_md}\n\n")
-
-    results = kg_store.search_for_document_generation(query, limit=max_results, **scope_kwargs)
-    if not results:
-        fallback_ctx = kg_store.context_for_query(
-            query,
-            limit=max_results,
-            **scope_kwargs,
-        )
-        fallback_ctx, trimmed = _fit_to_budget(fallback_ctx or "", knowledge_budget)
-        # Lexical fallback: the hybrid document search found nothing, so the
-        # signal says lexical_only — exactly what chat reports in the same
-        # situation, never a quiet downgrade.
-        quality = context_quality_signal(
-            "lexical_only" if fallback_ctx else "none",
-            1 if fallback_ctx else 0,
-        )
-        assembled = _with_self_model(self_model_md, fallback_ctx)
-        return {
-            "query": query,
-            "context_markdown": assembled,
-            "sources": [],
-            "stats": {"method": "fallback", "matches": 0, "budget_trimmed": trimmed},
-            "context_quality": quality,
-            "trace": {
-                "budget_approx_tokens": budget,
-                "used_approx_tokens": approx_tokens(assembled),
-                "sections": _self_model_trace(self_model_md) + [{
-                    "name": "Knowledge (fallback)",
-                    "source": "knowledge",
-                    "approx_tokens": approx_tokens(fallback_ctx),
-                    "provenance": [],
-                }],
-            },
-        }
-
-    seed_ids = [r["id"] for r in results]
-    hop_data = kg_store.multi_hop_context(
-        seed_ids,
-        max_hops=max_hops,
-        **scope_kwargs,
-    )
-
-    extra_nodes_by_id = {}
-    for node in hop_data.get("nodes", []):
-        if node["id"] not in {r["id"] for r in results}:
-            extra_nodes_by_id[node["id"]] = node
-
-    sections = _build_context_sections(results, extra_nodes_by_id, hop_data.get("edges", []))
-    context_md = _render_markdown(query, sections)
-    sources = _extract_sources(results)
-    context_md, trimmed = _fit_to_budget(context_md, knowledge_budget)
-    assembled = _with_self_model(self_model_md, context_md)
-
-    return {
-        "query": query,
-        "context_markdown": assembled,
-        "sources": sources,
-        "stats": {
-            "method": "hybrid",
-            "primary_matches": len(results),
-            "graph_nodes": len(hop_data.get("nodes", [])),
-            "graph_edges": len(hop_data.get("edges", [])),
-            "budget_trimmed": trimmed,
-        },
-        # Same honest signal chat reports for the same Brain — including the
-        # multimodal key when the document's context really rests on pictures.
-        "context_quality": context_quality_signal(
-            "hybrid", len(results), multimodal=multimodal_signal(results)
-        ),
-        "trace": {
-            "budget_approx_tokens": budget,
-            "used_approx_tokens": approx_tokens(assembled),
-            "sections": _self_model_trace(self_model_md) + [
-                {
-                    "name": section["title"],
-                    "source": "knowledge",
-                    "approx_tokens": approx_tokens(
-                        " ".join(str(item.get("summary") or "") for item in section["items"])
-                    ),
-                    "provenance": [
-                        {"id": item.get("id"), "type": item.get("type")}
-                        for item in section["items"][:8]
-                    ],
-                }
-                for section in sections
-            ],
-        },
-    }
-
-
-def _build_context_sections(
-    primary_results: List[Dict[str, Any]],
-    extra_nodes: Dict[str, Dict[str, Any]],
-    edges: List[Dict[str, Any]],
-) -> List[Dict[str, Any]]:
-    sections = []
-
-    docs = [r for r in primary_results if r["type"] in (
-        "Document", "File", "SlideDeck", "Spreadsheet", "CodeFile", "Image", "ImageText",
-        "Audio",
-    )]
-    if docs:
-        sections.append({
-            "title": "관련 문서/파일",
-            "items": docs,
-            "icon": "📄",
-        })
-
-    decisions = [r for r in primary_results if r["type"] in ("Decision", "Task")]
-    if decisions:
-        sections.append({
-            "title": "관련 결정사항/작업",
-            "items": decisions,
-            "icon": "✅",
-        })
-
-    conversations = [r for r in primary_results if r["type"] == "Chat"]
-    if conversations:
-        sections.append({
-            "title": "관련 대화",
-            "items": conversations,
-            "icon": "💬",
-        })
-
-    concepts = [r for r in primary_results if r["type"] in ("Concept", "Feature")]
-    extra_concepts = [n for n in extra_nodes.values() if n["type"] in ("Concept", "Feature")]
-    all_concepts = concepts + extra_concepts[:8]
-    if all_concepts:
-        sections.append({
-            "title": "관련 개념/기술",
-            "items": all_concepts,
-            "icon": "🔗",
-        })
-
-    return sections
-
-
-def _render_markdown(query: str, sections: List[Dict[str, Any]]) -> str:
-    lines = []
-    for section in sections:
-        if not section["items"]:
-            continue
-        lines.append(f"### {section['icon']} {section['title']}")
-        lines.append("")
-        for item in section["items"][:8]:
-            title = item.get("title", "")
-            summary = _clean(item.get("summary", ""))
-            item_type = item.get("type", "")
-            score_info = ""
-            if "hybrid_score" in item:
-                score_info = f" (relevance: {item['hybrid_score']:.2f})"
-
-            meta = item.get("metadata") or {}
-            source = (
-                meta.get("relative_path")
-                or meta.get("filename")
-                or meta.get("conversation_id")
-                or meta.get("source")
-                or item.get("id", "")
-            )
-
-            lines.append(f"- **[{item_type}] {title}**{score_info}")
-            if source and source != item.get("id", ""):
-                lines.append(f"  - 출처: {source}")
-            if summary:
-                lines.append(f"  - {summary}")
-
-            related = item.get("related_concepts", [])
-            if related:
-                tags = ", ".join(c["title"] for c in related[:5])
-                lines.append(f"  - 관련: {tags}")
-
-            lines.append("")
-
-    return "\n".join(lines).strip()
-
-
-def _extract_sources(results: List[Dict[str, Any]]) -> List[Dict[str, str]]:
-    sources = []
-    seen = set()
-    for r in results:
-        meta = r.get("metadata") or {}
-        source_key = (
-            meta.get("relative_path")
-            or meta.get("filename")
-            or meta.get("conversation_id")
-            or r.get("id", "")
-        )
-        if source_key and source_key not in seen:
-            seen.add(source_key)
-            sources.append({
-                "id": r.get("id", ""),
-                "type": r.get("type", ""),
-                "title": r.get("title", ""),
-                "source": source_key,
-            })
-    return sources
-
-
-def format_sources_footnote(sources: List[Dict[str, str]]) -> str:
-    if not sources:
-        return ""
-    lines = ["\n---\n**참조된 지식 그래프 노드:**"]
-    for i, src in enumerate(sources[:10], 1):
-        lines.append(f"{i}. [{src['type']}] {src['title']} ({src['source']})")
-    return "\n".join(lines)

package/latticeai/core/document_generator.py

@@ -1,103 +0,0 @@
-"""
-Document Generator — 지식 그래프 기반 고품질 문서 자동 생성 모듈.
-
-사용자가 "Q3 마케팅 전략 보고서 작성해줘" 같은 일반 채팅을 하면,
-Knowledge Graph에서 관련 과거 문서/개념/관계를 자동으로 찾아
-LLM이 자연스럽고 일관성 있게 새로운 문서를 생성한다.
-"""
-
-import re
-from typing import Optional
-
-_DOCUMENT_INTENT_PATTERNS = [
-    re.compile(r"(보고서|계획서|기획서|제안서|문서|리포트|요약서|분석서|전략서|매뉴얼|가이드)", re.IGNORECASE),
-    re.compile(r"(작성|만들어|생성|써|줘|write|create|generate|draft|compose|prepare)", re.IGNORECASE),
-    re.compile(r"(report|proposal|plan|document|summary|analysis|strategy|guide|manual|brief)", re.IGNORECASE),
-]
-
-_STRONG_INTENT_PATTERNS = [
-    re.compile(r"(작성해|만들어\s*줘|써\s*줘|생성해|write\s+(?:a|me|the)|create\s+(?:a|me|the)|draft\s+(?:a|me|the))", re.IGNORECASE),
-    re.compile(r"(보고서|계획서|기획서|제안서|전략서|매뉴얼).*(작성|만들|생성|써)", re.IGNORECASE),
-    re.compile(r"(작성|만들|생성|써).*(보고서|계획서|기획서|제안서|전략서|매뉴얼)", re.IGNORECASE),
-]
-
-
-def detect_document_intent(message: str) -> bool:
-    """Detect whether the user's message is requesting document generation."""
-    if not message or len(message) < 5:
-        return False
-    for pattern in _STRONG_INTENT_PATTERNS:
-        if pattern.search(message):
-            return True
-    hit_count = sum(1 for p in _DOCUMENT_INTENT_PATTERNS if p.search(message))
-    return hit_count >= 2
-
-
-DOCUMENT_GENERATION_SYSTEM_PROMPT = """당신은 사용자의 개인 AI 지식 어시스턴트 Lattice AI입니다.
-사용자의 기존 지식 기반을 활용하여 고품질 문서를 생성합니다.
-
-## 지침
-1. 아래 제공된 지식 그래프 컨텍스트를 최대한 활용하세요.
-2. 이전 문서의 스타일과 톤을 유지하면서 최신적이고 전문적인 문서를 작성하세요.
-3. 출처는 자연스럽게 본문이나 각주에 포함하세요.
-4. 사용자의 언어(한국어/영어)에 맞춰 작성하세요.
-5. 구조화된 포맷(제목, 소제목, 목록 등)을 사용하세요.
-
-## 사용자의 지식 기반
-
-{graph_context}"""
-
-DOCUMENT_GENERATION_FOLLOWUP_PROMPT = """당신은 사용자의 개인 AI 지식 어시스턴트 Lattice AI입니다.
-이전에 생성한 문서를 사용자의 요청에 따라 수정/보완합니다.
-
-## 이전 생성 컨텍스트
-
-{graph_context}
-
-## 이전 문서
-{previous_document}
-
-위 문서를 사용자의 요청에 따라 수정하세요. 기존 스타일과 톤을 유지하세요."""
-
-
-def build_document_system_prompt(graph_context: str) -> str:
-    if not graph_context:
-        return DOCUMENT_GENERATION_SYSTEM_PROMPT.replace("{graph_context}", "(사용 가능한 지식 기반이 없습니다. 일반 지식을 활용하여 작성합니다.)")
-    return DOCUMENT_GENERATION_SYSTEM_PROMPT.replace("{graph_context}", graph_context)
-
-
-def build_followup_system_prompt(graph_context: str, previous_document: str) -> str:
-    prompt = DOCUMENT_GENERATION_FOLLOWUP_PROMPT.replace("{graph_context}", graph_context or "(없음)")
-    return prompt.replace("{previous_document}", previous_document or "(없음)")
-
-
-class DocumentGenerationSession:
-    """Maintains state across iterative document generation requests."""
-
-    def __init__(self):
-        self._last_context: Optional[str] = None
-        self._last_document: Optional[str] = None
-        self._conversation_id: Optional[str] = None
-
-    @property
-    def has_previous(self) -> bool:
-        return self._last_document is not None
-
-    def update(self, context: str, document: str, conversation_id: Optional[str] = None) -> None:
-        self._last_context = context
-        self._last_document = document
-        if conversation_id:
-            self._conversation_id = conversation_id
-
-    def get_system_prompt(self, graph_context: str) -> str:
-        if self.has_previous:
-            return build_followup_system_prompt(
-                graph_context or self._last_context or "",
-                self._last_document or "",
-            )
-        return build_document_system_prompt(graph_context)
-
-    def clear(self) -> None:
-        self._last_context = None
-        self._last_document = None
-        self._conversation_id = None

package/latticeai/core/enterprise.py

@@ -1,154 +0,0 @@
-"""Enterprise extension seam (open-core boundary).
-
-LatticeAI Community is fully functional on its own. This module defines the
-*seam* where a future, separately-distributed Enterprise plugin can attach
-advanced capabilities (SSO provisioning, SCIM, tenant isolation, compliance
-retention, SIEM export, and so on) **without** any of that code living in the
-public Community repository.
-
-Design rules enforced here:
-
-* Community is the default :class:`Edition`. Every :class:`EnterpriseCapability`
-  is **disabled** unless an Enterprise provider is explicitly registered.
-* Nothing in this module restricts or gates a Community feature. It only answers
-  "is this *Enterprise* capability available?" — which is ``False`` in the open
-  build.
-* Enterprise behaviour is supplied at runtime through
-  :class:`CapabilityProvider` implementations registered on the shared
-  :data:`capability_registry`. The public code never imports Enterprise code.
-"""
-
-from __future__ import annotations
-
-import os
-from enum import Enum
-from typing import Dict, Protocol, runtime_checkable
-
-
-class Edition(str, Enum):
-    """Distribution edition. Community is the open-source default."""
-
-    COMMUNITY = "community"
-    ENTERPRISE = "enterprise"
-
-
-class EnterpriseCapability(str, Enum):
-    """Capabilities reserved for the Enterprise edition.
-
-    These are documented in ``docs/ENTERPRISE.md``. They are intentionally
-    declared (so the seam is stable and discoverable) but never implemented in
-    the Community build.
-    """
-
-    SSO_ADVANCED = "sso_advanced"
-    IDP_PROVISIONING = "idp_provisioning"  # Entra ID / Okta provisioning
-    SCIM = "scim"
-    RBAC_ABAC_ADVANCED = "rbac_abac_advanced"
-    TENANT_ISOLATION = "tenant_isolation"
-    COMPLIANCE_RETENTION = "compliance_retention"
-    SIEM_EXPORT = "siem_export"
-    PRIVATE_VPC = "private_vpc"
-    AIR_GAPPED_DEPLOYMENT = "air_gapped_deployment"
-    DLP_POLICY = "dlp_policy"
-    EDISCOVERY = "ediscovery"
-    ADMIN_POLICY_PACKS = "admin_policy_packs"
-    # Human review-before-promote governance for knowledge-graph concept
-    # promotions (review 2026-07-25 Wave 4). Community users can opt in per
-    # deployment via LATTICEAI_GRAPH_PROMOTION_REVIEW; this capability is the
-    # seam for Enterprise policy packs that mandate reviewed promotions.
-    GRAPH_PROMOTION_REVIEW = "graph_promotion_review"
-
-
-@runtime_checkable
-class CapabilityProvider(Protocol):
-    """Contract an Enterprise plugin implements to light up capabilities.
-
-    A provider is registered at runtime via
-    :meth:`CapabilityRegistry.register_provider`. The Community build ships no
-    provider, so :meth:`is_enabled` is effectively ``False`` everywhere.
-    """
-
-    def edition(self) -> Edition:
-        ...
-
-    def is_enabled(self, capability: EnterpriseCapability) -> bool:
-        ...
-
-
-class CommunityCapabilityProvider:
-    """Default provider: Community edition, no Enterprise capabilities."""
-
-    def edition(self) -> Edition:
-        return Edition.COMMUNITY
-
-    def is_enabled(self, capability: EnterpriseCapability) -> bool:  # noqa: ARG002
-        return False
-
-
-class CapabilityRegistry:
-    """Runtime seam that an Enterprise plugin can attach a provider to.
-
-    The registry holds at most one active provider. Until an Enterprise build
-    registers one, the :class:`CommunityCapabilityProvider` answers every query
-    with "Community / disabled".
-    """
-
-    def __init__(self) -> None:
-        self._provider: CapabilityProvider = CommunityCapabilityProvider()
-
-    def register_provider(self, provider: CapabilityProvider) -> None:
-        if not isinstance(provider, CapabilityProvider):
-            raise TypeError("provider must implement the CapabilityProvider protocol")
-        self._provider = provider
-
-    def reset(self) -> None:
-        """Restore the Community default provider (used by tests)."""
-        self._provider = CommunityCapabilityProvider()
-
-    def edition(self) -> Edition:
-        return self._provider.edition()
-
-    def is_capability_enabled(self, capability: EnterpriseCapability) -> bool:
-        try:
-            return bool(self._provider.is_enabled(capability))
-        except Exception:
-            # A misbehaving plugin must never break a Community request.
-            return False
-
-    def describe(self) -> Dict[str, object]:
-        """Edition + capability matrix for ``/workspace/editions`` and admin UI."""
-        return {
-            "edition": self.edition().value,
-            "is_enterprise": self.edition() is Edition.ENTERPRISE,
-            "capabilities": {
-                cap.value: self.is_capability_enabled(cap) for cap in EnterpriseCapability
-            },
-            "community_notice": (
-                "All listed capabilities are Enterprise-only extension points. "
-                "The open-source Community edition ships none of them enabled; "
-                "see docs/ENTERPRISE.md and docs/EDITION_STRATEGY.md."
-            ),
-        }
-
-
-# Shared singleton seam. Enterprise plugins import this and call
-# ``capability_registry.register_provider(...)`` during their own startup.
-capability_registry = CapabilityRegistry()
-
-
-def detect_edition() -> Edition:
-    """Best-effort edition detection.
-
-    Honours an explicit ``LATTICE_EDITION=enterprise`` opt-in for environments
-    that have separately installed an Enterprise provider, but otherwise the
-    registry's active provider is the source of truth.
-    """
-    env = os.environ.get("LATTICE_EDITION", "").strip().lower()
-    if env == Edition.ENTERPRISE.value and capability_registry.edition() is Edition.ENTERPRISE:
-        return Edition.ENTERPRISE
-    return capability_registry.edition()
-
-
-def is_capability_enabled(capability: EnterpriseCapability) -> bool:
-    """Module-level convenience used by Community code at extension points."""
-    return capability_registry.is_capability_enabled(capability)