plm-knowledge 1.0.0__py3-none-any.whl

plm_knowledge/issue_classification.py

@@ -0,0 +1,155 @@
+"""
+Issue Classification Dictionary and Severity Policy (US-42.3 / FTR-42).
+
+Governance asset — pure Python data structures (NOT persisted in DB).
+Maps finding_type → issue classification metadata for deterministic,
+traceable severity and resolution-category assignment.
+"""
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+
+@dataclass(frozen=True)
+class IssueClassificationEntry:
+    """Immutable classification record for a known issue type."""
+    issue_code: str                    # e.g. "STR_ORPHAN_NODE"
+    issue_label: str                   # e.g. "Orphan node"
+    issue_category: str                # structural | data_quality | configuration
+    default_severity: str              # critical | high | medium | low
+    default_priority: int              # 0 = highest
+    default_resolution_category: str   # auto_fix | suggested_remediation | business_decision_required
+    requires_business_review: bool
+    structural_scope_type: str         # local_node | subtree | multi_node | structure_wide
+
+
+# ---------------------------------------------------------------------------
+# Severity Policy — explicit operational meaning for each level
+# ---------------------------------------------------------------------------
+SEVERITY_POLICY: Dict[str, str] = {
+    "critical": "Issue likely to prevent transformation, load, or core structure consistency",
+    "high": "Issue with high structural or migration impact requiring correction before safe continuation",
+    "medium": "Localized issue with limited migration impact, still requiring correction or review",
+    "low": "Signal worth surfacing but with low operational urgency",
+}
+
+SEVERITY_ORDER: Dict[str, int] = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+
+
+# ---------------------------------------------------------------------------
+# Issue Classification Dictionary — one entry per known finding_type
+# ---------------------------------------------------------------------------
+ISSUE_CLASSIFICATION_DICT: Dict[str, IssueClassificationEntry] = {
+    "cycle": IssueClassificationEntry(
+        issue_code="STR_CYCLE",
+        issue_label="Cycle detected",
+        issue_category="structural",
+        default_severity="critical",
+        default_priority=0,
+        default_resolution_category="business_decision_required",
+        requires_business_review=True,
+        structural_scope_type="subtree",
+    ),
+    "missing_reference": IssueClassificationEntry(
+        issue_code="STR_MISSING_REF",
+        issue_label="Missing reference",
+        issue_category="structural",
+        default_severity="high",
+        default_priority=1,
+        default_resolution_category="suggested_remediation",
+        requires_business_review=False,
+        structural_scope_type="multi_node",
+    ),
+    "self_reference": IssueClassificationEntry(
+        issue_code="STR_SELF_REF",
+        issue_label="Self-referencing relation",
+        issue_category="structural",
+        default_severity="high",
+        default_priority=1,
+        default_resolution_category="auto_fix",
+        requires_business_review=False,
+        structural_scope_type="local_node",
+    ),
+    "broken_link": IssueClassificationEntry(
+        issue_code="STR_BROKEN_LINK",
+        issue_label="Broken link",
+        issue_category="structural",
+        default_severity="high",
+        default_priority=1,
+        default_resolution_category="suggested_remediation",
+        requires_business_review=False,
+        structural_scope_type="local_node",
+    ),
+    "orphan_node": IssueClassificationEntry(
+        issue_code="STR_ORPHAN_NODE",
+        issue_label="Orphan node",
+        issue_category="structural",
+        default_severity="medium",
+        default_priority=2,
+        default_resolution_category="suggested_remediation",
+        requires_business_review=False,
+        structural_scope_type="local_node",
+    ),
+    "duplicate_relation": IssueClassificationEntry(
+        issue_code="STR_DUPLICATE_REL",
+        issue_label="Duplicate relation",
+        issue_category="structural",
+        default_severity="medium",
+        default_priority=2,
+        default_resolution_category="auto_fix",
+        requires_business_review=False,
+        structural_scope_type="local_node",
+    ),
+}
+
+
+# ---------------------------------------------------------------------------
+# Fallback — used when finding_type is unknown or unmapped
+# ---------------------------------------------------------------------------
+FALLBACK_ENTRY = IssueClassificationEntry(
+    issue_code="UNK_UNCLASSIFIED",
+    issue_label="Unclassified issue",
+    issue_category="unclassified",
+    default_severity="medium",
+    default_priority=3,
+    default_resolution_category="suggested_remediation",
+    requires_business_review=False,
+    structural_scope_type="local_node",
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def classify_finding(finding_type: str) -> IssueClassificationEntry:
+    """Look up classification for a finding_type. Falls back gracefully."""
+    return ISSUE_CLASSIFICATION_DICT.get(finding_type, FALLBACK_ENTRY)
+
+
+def arbitrate_severity(finding_severity: str, dict_severity: str) -> str:
+    """Severity arbitration: highest severity wins.
+
+    Returns the more severe of the two levels.
+    """
+    f_rank = SEVERITY_ORDER.get(finding_severity, 99)
+    d_rank = SEVERITY_ORDER.get(dict_severity, 99)
+    # Lower rank = more severe
+    if f_rank <= d_rank:
+        return finding_severity
+    return dict_severity
+
+
+def compute_priority(severity: str, scope_type: str) -> int:
+    """Derive priority from severity + scope.
+
+    Lower number = higher priority.
+    Wider scope at the same severity bumps priority up.
+    """
+    base = SEVERITY_ORDER.get(severity, 3)
+    scope_bonus = {
+        "structure_wide": -1,
+        "subtree": 0,
+        "multi_node": 0,
+        "local_node": 1,
+    }
+    return max(0, base + scope_bonus.get(scope_type, 0))

plm_knowledge/knowledge_pack_loader.py

@@ -0,0 +1,177 @@
+"""
+KnowledgePackLoader — charge et découpe les fichiers Markdown de 01_Dictionnaries
+en chunks indexables pour le moteur BM25.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Domaines PLM — heuristique sur le nom de fichier (stem)
+# ---------------------------------------------------------------------------
+_DOMAIN_RULES: list[tuple[list[str], str]] = [
+    (["EBOM", "MBOM", "BoM", "CAD BOM", "Baseline"], "bill_of_materials"),
+    (["Change Management", "EIA-649", "CMII"], "change_management"),
+    (["DFMEA", "APQP", "CQCP", "CQCS", "IMR", "ISO 10005"], "quality"),
+    # bpmn/ handled separately via path
+    (["AML", "AVL", "ATO", "MTO", "MTS", "CTO", "ETO"], "supply_chain"),
+    (["ALM", "PDM"], "pdm"),
+]
+
+_EXCLUDED_STEMS = {"BIM (Building Information Modeling)", "IaaS", "PaaS", "SaaS"}
+_EXCLUDED_DIRS = {"rgpd", "data", "prompt_library"}
+
+
+def _map_domain(path: Path) -> Optional[str]:
+    """Heuristique domaine à partir du chemin relatif."""
+    parts = [p.lower() for p in path.parts]
+    if "bpmn" in parts:
+        return "process_management"
+    if "ontology" in parts:
+        return "general_plm"
+    if "customers" in parts:
+        return "general_plm"
+    stem = path.stem
+    for keywords, domain in _DOMAIN_RULES:
+        for kw in keywords:
+            if kw.lower() in stem.lower():
+                return domain
+    return "general_plm"
+
+
+def _slug(text: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+
+
+# ---------------------------------------------------------------------------
+# Dataclass chunk
+# ---------------------------------------------------------------------------
+@dataclass
+class KnowledgeChunk:
+    id: str               # "{filename}#{section_slug}"
+    content: str          # texte de la section
+    source_file: str      # chemin relatif dans 01_Dictionnaries
+    section_title: str    # titre du ## heading (ou "intro" pour contenu avant premier ##)
+    domain: Optional[str] = field(default=None)
+
+
+# ---------------------------------------------------------------------------
+# Loader
+# ---------------------------------------------------------------------------
+class KnowledgePackLoader:
+    """Charge les fichiers Markdown et les découpe par sections (## headings)."""
+
+    def __init__(self, dictionnaries_path: str = "../../01_Dictionnaries") -> None:
+        self.root = Path(dictionnaries_path).resolve()
+        self.chunks: list[KnowledgeChunk] = []
+
+    # ------------------------------------------------------------------
+    def load(self) -> list[KnowledgeChunk]:
+        """Charge tous les fichiers éligibles et retourne la liste de chunks."""
+        self.chunks = []
+        for path in self._get_relevant_files():
+            try:
+                new_chunks = self._chunk_markdown(path)
+                self.chunks.extend(new_chunks)
+            except Exception as exc:  # noqa: BLE001
+                # Fichier illisible — on ignore sans bloquer
+                pass
+        return self.chunks
+
+    # ------------------------------------------------------------------
+    def _get_relevant_files(self) -> list[Path]:
+        if not self.root.exists():
+            return []
+
+        files: list[Path] = []
+
+        # Tier 1 : plm/, bpmn/, ontology/
+        for folder in ("plm", "bpmn", "ontology"):
+            folder_path = self.root / folder
+            if folder_path.is_dir():
+                for md in folder_path.glob("*.md"):
+                    if self._is_included(md):
+                        files.append(md)
+
+        # Tier 2 : customers/schneider-electrics/
+        se_root = self.root / "customers" / "schneider-electrics"
+        if se_root.is_dir():
+            # Fichier racine Schneider
+            for md in se_root.glob("*.md"):
+                if self._is_included(md):
+                    files.append(md)
+            # Sous-dossier "3. Epics"
+            epics_dir = se_root / "3. Epics"
+            if epics_dir.is_dir():
+                for md in epics_dir.glob("*.md"):
+                    if self._is_included(md):
+                        files.append(md)
+
+        return files
+
+    # ------------------------------------------------------------------
+    def _is_included(self, path: Path) -> bool:
+        rel = path.relative_to(self.root)
+        parts = [p.lower() for p in rel.parts]
+        # Exclure répertoires interdits
+        for excl in _EXCLUDED_DIRS:
+            if excl in parts:
+                return False
+        # Exclure stems explicitement exclus (plm/BIM*.md, IaaS, PaaS, SaaS)
+        stem = path.stem
+        if stem in _EXCLUDED_STEMS:
+            return False
+        if stem.startswith("BIM"):
+            return False
+        # Exclure fichiers index/attachments peu utiles
+        if stem.lower() in {"attachments", "index"}:
+            return False
+        return True
+
+    # ------------------------------------------------------------------
+    def _chunk_markdown(self, path: Path) -> list[KnowledgeChunk]:
+        """Découpe un fichier .md en sections délimitées par des ## headings."""
+        rel = str(path.relative_to(self.root))
+        domain = _map_domain(path.relative_to(self.root))
+        text = path.read_text(encoding="utf-8", errors="replace")
+
+        chunks: list[KnowledgeChunk] = []
+        # Split sur les headings de niveau 2 (##)
+        sections = re.split(r"\n(?=## )", text)
+
+        for i, section in enumerate(sections):
+            lines = section.strip().splitlines()
+            if not lines:
+                continue
+
+            # Titre de section
+            if lines[0].startswith("## "):
+                title = lines[0][3:].strip()
+                body = "\n".join(lines[1:]).strip()
+            elif i == 0:
+                # Contenu avant le premier ## heading (intro / titre #)
+                # Prendre le premier # heading comme titre si présent
+                h1 = next((ln[2:].strip() for ln in lines if ln.startswith("# ")), path.stem)
+                title = h1
+                body = section.strip()
+            else:
+                title = path.stem
+                body = section.strip()
+
+            if not body or len(body) < 30:
+                continue
+
+            chunk_id = f"{_slug(path.stem)}#{_slug(title)}"
+            chunks.append(KnowledgeChunk(
+                id=chunk_id,
+                content=body[:4000],  # cap à 4000 chars par chunk
+                source_file=rel,
+                section_title=title,
+                domain=domain,
+            ))
+
+        return chunks

plm_knowledge/knowledge_search_engine.py

@@ -0,0 +1,140 @@
+"""
+KnowledgeSearchEngine — index BM25 sur les KnowledgeChunks PLM.
+
+Trois alternatives de moteur de recherche ont été évaluées :
+1. BM25 (rank_bm25) — CHOIX RETENU
+   Avantages : dépendance ~10KB, démarrage instantané, excellent sur vocabulaire
+   technique précis (PLM, normes, acronymes). Pas de modèle à charger.
+   Limite : ne comprend pas les synonymes (ex: "validité" ≠ "effectivité").
+
+2. TF-IDF (scikit-learn)
+   Qualité similaire à BM25 sur texte structuré. ~50MB de dépendance (sklearn).
+   Démarrage ~1s. Envisageable si sklearn est déjà présent dans le projet.
+
+3. Embeddings sémantiques (sentence-transformers)
+   Comprend les synonymes et paraphrases. Modèle ~500MB à télécharger.
+   Démarrage 10-30s, RAM ~600MB. Recommandé si le corpus dépasse 1000 chunks
+   ou si les utilisateurs posent des questions en langage naturel non-technique.
+   Modèle suggéré : 'paraphrase-multilingual-MiniLM-L12-v2' (multilingue FR/EN).
+"""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from plm_knowledge.knowledge_pack_loader import KnowledgeChunk, KnowledgePackLoader
+
+try:
+    from rank_bm25 import BM25Okapi
+    _BM25_AVAILABLE = True
+except ImportError:
+    _BM25_AVAILABLE = False
+
+
+# ---------------------------------------------------------------------------
+# Tokenizer simple (alphanumérique + accents FR)
+# ---------------------------------------------------------------------------
+def _tokenize(text: str) -> list[str]:
+    return re.findall(r"[a-zA-Z0-9\u00C0-\u024F]+", text.lower())
+
+
+# ---------------------------------------------------------------------------
+# Engine
+# ---------------------------------------------------------------------------
+class KnowledgeSearchEngine:
+    """
+    Index BM25 chargé en mémoire. Recherche par query + filtre domaine optionnel.
+    """
+
+    MIN_SCORE = 0.1  # Seuil de pertinence
+
+    def __init__(self, loader: KnowledgePackLoader) -> None:
+        self.chunks: list[KnowledgeChunk] = loader.chunks
+        self.is_ready = False
+        self._bm25: Optional[object] = None
+        self._tokenized: list[list[str]] = []
+
+        if not _BM25_AVAILABLE:
+            return
+        if not self.chunks:
+            return
+
+        self._tokenized = [_tokenize(c.content + " " + c.section_title) for c in self.chunks]
+        self._bm25 = BM25Okapi(self._tokenized)
+        self.is_ready = True
+
+    # ------------------------------------------------------------------
+    def search(
+        self,
+        query: str,
+        domain: Optional[str] = None,
+        top_k: int = 3,
+    ) -> list[KnowledgeChunk]:
+        """
+        Recherche les chunks les plus pertinents pour une query.
+
+        Args:
+            query:  Texte de la requête (ex: "effectivité eBOM révision")
+            domain: Filtre domaine optionnel (ex: "bill_of_materials")
+            top_k:  Nombre maximal de résultats
+
+        Returns:
+            Liste triée par score BM25 décroissant, filtrée par MIN_SCORE.
+        """
+        if not self.is_ready or not query:
+            return []
+
+        tokens = _tokenize(query)
+        if not tokens:
+            return []
+
+        scores = self._bm25.get_scores(tokens)
+
+        # Associer score + chunk
+        scored = list(zip(scores, self.chunks))
+
+        # Filtre domaine
+        if domain:
+            scored = [(s, c) for s, c in scored if c.domain == domain or c.domain is None]
+
+        # Seuil de pertinence
+        scored = [(s, c) for s, c in scored if s >= self.MIN_SCORE]
+
+        # Tri décroissant + top_k
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [c for _, c in scored[:top_k]]
+
+    # ------------------------------------------------------------------
+    def format_for_prompt(self, chunks: list[KnowledgeChunk]) -> str:
+        """
+        Formate les chunks en bloc texte prêt à être injecté dans un system prompt.
+
+        Format :
+            [Connaissances PLM pertinentes]
+            Source: plm/EBOM.md — ## Effectivité
+            <contenu...>
+        """
+        if not chunks:
+            return ""
+
+        lines = ["[Connaissances PLM pertinentes]"]
+        for chunk in chunks:
+            lines.append(f"\nSource: {chunk.source_file} — ## {chunk.section_title}")
+            lines.append(chunk.content)
+
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Singleton (lazy-loaded)
+# ---------------------------------------------------------------------------
+_engine_instance: Optional[KnowledgeSearchEngine] = None
+
+
+def set_engine(engine: KnowledgeSearchEngine) -> None:
+    global _engine_instance
+    _engine_instance = engine
+
+
+def get_knowledge_engine() -> Optional[KnowledgeSearchEngine]:
+    return _engine_instance

plm_knowledge/lifecycle.py

@@ -0,0 +1,115 @@
+"""4-state lifecycle FSM for knowledge-pack manifests.
+
+Aligned verbatim with PRD §8.11.3 capability lifecycle, mirroring the
+Wave 6.5 Conv A `plm_skill_packages.lifecycle` precedent (Decision #167
+/ Q-W6.5A-2 = (a) "Align verbatim with PRD §8.11.3 4-state capability
+lifecycle"). No new states, no knowledge-specific extensions, no
+standalone divergence.
+
+State chart::
+
+    draft ──► released ──► deprecated ──► retired
+                                              │
+                                              └──► (terminal)
+
+States are **strictly forward-flowing**. The FSM rejects:
+  * any transition not in ``LIFECYCLE_TRANSITIONS``
+  * any move out of a terminal state
+  * skip transitions (e.g. ``draft → deprecated``)
+
+Used by ``plm_knowledge.registry.KnowledgePackRegistry`` to gate
+manifest publishing + by future admin tools (V1.1+) to mediate
+state-change audit events.
+
+Wave 6.5 Conv B constraint: this module is the SOLE lifecycle FSM
+for knowledge-pack manifests. The shared 4-state contract sits in
+``plm_shared.capability_registry`` (PRD §8.11.3) and is mirrored
+here verbatim — string identifiers chosen to match for cross-checks
+in ``tests/test_lifecycle.py``.
+"""
+from __future__ import annotations
+
+from typing import Tuple
+
+# ── Canonical state identifiers (PRD §8.11.3 verbatim) ─────────────────────
+
+STATE_DRAFT: str = "draft"
+STATE_RELEASED: str = "released"
+STATE_DEPRECATED: str = "deprecated"
+STATE_RETIRED: str = "retired"
+
+LIFECYCLE_STATES: Tuple[str, ...] = (
+    STATE_DRAFT,
+    STATE_RELEASED,
+    STATE_DEPRECATED,
+    STATE_RETIRED,
+)
+
+# ── Allowed transitions (forward-flowing only) ─────────────────────────────
+#
+# Each tuple is (from, to). Skips are rejected (no draft→deprecated). Out-
+# of-terminal moves are rejected (no retired→anywhere).
+
+LIFECYCLE_TRANSITIONS: Tuple[Tuple[str, str], ...] = (
+    (STATE_DRAFT, STATE_RELEASED),
+    (STATE_RELEASED, STATE_DEPRECATED),
+    (STATE_DEPRECATED, STATE_RETIRED),
+)
+
+TERMINAL_STATES: Tuple[str, ...] = (STATE_RETIRED,)
+
+
+class InvalidLifecycleTransition(ValueError):
+    """Raised on any state move that is not in ``LIFECYCLE_TRANSITIONS``.
+
+    Carries the attempted (from_state, to_state) pair so callers
+    (e.g. registry publishing flow) can emit a precise audit event.
+    """
+
+    def __init__(self, from_state: str, to_state: str) -> None:
+        self.from_state = from_state
+        self.to_state = to_state
+        super().__init__(
+            f"invalid lifecycle transition: {from_state!r} → {to_state!r} "
+            f"(allowed: {sorted(LIFECYCLE_TRANSITIONS)})"
+        )
+
+
+def is_terminal(state: str) -> bool:
+    """Return True iff ``state`` is a terminal state (no outbound transitions)."""
+    return state in TERMINAL_STATES
+
+
+def can_transition(from_state: str, to_state: str) -> bool:
+    """Return True iff ``(from_state, to_state)`` is in ``LIFECYCLE_TRANSITIONS``."""
+    return (from_state, to_state) in LIFECYCLE_TRANSITIONS
+
+
+def next_state(from_state: str, to_state: str) -> str:
+    """Apply the transition and return ``to_state``; raise on invalid moves.
+
+    Pure function — does NOT persist; the caller (registry) writes the
+    new state into the manifest store after this returns successfully.
+    """
+    if from_state not in LIFECYCLE_STATES:
+        raise InvalidLifecycleTransition(from_state, to_state)
+    if to_state not in LIFECYCLE_STATES:
+        raise InvalidLifecycleTransition(from_state, to_state)
+    if not can_transition(from_state, to_state):
+        raise InvalidLifecycleTransition(from_state, to_state)
+    return to_state
+
+
+__all__ = [
+    "STATE_DRAFT",
+    "STATE_RELEASED",
+    "STATE_DEPRECATED",
+    "STATE_RETIRED",
+    "LIFECYCLE_STATES",
+    "LIFECYCLE_TRANSITIONS",
+    "TERMINAL_STATES",
+    "InvalidLifecycleTransition",
+    "is_terminal",
+    "can_transition",
+    "next_state",
+]

plm_knowledge/manifests/foundation.dictionnaries.yaml

@@ -0,0 +1,17 @@
+pack_id: foundation.dictionnaries
+kind: foundation_dictionary
+title: Foundation — 01_Dictionnaries Markdown corpus
+description: 146 PLM domain markdown files at 01_Dictionnaries/ (path resolved via plm_knowledge.foundation_loader; physical relocation deferred to Wave 7 per Decision #171).
+version: 1.0.0
+lifecycle_state: released
+capability_id: knowledge.foundation.dictionnaries
+entry_module: plm_knowledge.foundation_loader
+entry_callable: list_foundation_documents
+tags:
+  - foundation
+  - markdown
+  - dictionnaries
+notes: |
+  Wave 6.5 Conv B carve: directory stays at repo root through Wave 6.5; the
+  thin loader resolves the path through backend `config.dictionnaries_path`.
+  Physical relocation lands at Wave 7 Extraction.

plm_knowledge/manifests/foundation.evaluation_grids.yaml

@@ -0,0 +1,16 @@
+pack_id: foundation.evaluation_grids
+kind: foundation_evaluation_grid
+title: Foundation — PLM evaluation grids
+description: PLM evaluation rubrics consumed by the business validator + quality gate; resolved through the Foundation root path resolver.
+version: 1.0.0
+lifecycle_state: released
+capability_id: knowledge.foundation.evaluation_grids
+entry_module: plm_knowledge.foundation_loader
+entry_callable: list_foundation_documents
+tags:
+  - foundation
+  - evaluation
+  - rubric
+notes: |
+  V1 sources rubrics from the shared 01_Dictionnaries tree (filtered subset).
+  V1.1+ may split into a dedicated foundation/grids/ subdirectory.

plm_knowledge/manifests/foundation.taxonomy.yaml

@@ -0,0 +1,15 @@
+pack_id: foundation.taxonomy
+kind: foundation_taxonomy
+title: Foundation — PLM taxonomy
+description: PLM domain taxonomy mappings (e.g. EBOM/MBOM/CAD-BOM, Change Management, Quality, Supply Chain) used by the BM25 loader to assign domain tags.
+version: 1.0.0
+lifecycle_state: released
+capability_id: knowledge.foundation.taxonomy
+entry_module: plm_knowledge.knowledge_pack_loader
+entry_callable: KnowledgePackLoader
+tags:
+  - foundation
+  - taxonomy
+notes: |
+  V1 surface lives inside knowledge_pack_loader's _DOMAIN_RULES heuristic.
+  V1.1+ promotes this to a standalone declarative file under foundation/.

plm_knowledge/manifests/operational.placeholder.yaml

@@ -0,0 +1,18 @@
+pack_id: operational.placeholder
+kind: operational
+title: Operational — V1 placeholder
+description: V1 operational layer placeholder per D-LOCKED-15 + Decision #172. Stable but inert public surface so downstream callers can wire against the contract today.
+version: 1.0.0
+lifecycle_state: draft
+capability_id: knowledge.operational.placeholder
+entry_module: plm_knowledge.operational
+entry_callable: record_operational_event
+tags:
+  - operational
+  - placeholder
+notes: |
+  V1 (Wave 6.5 Conv B): no-op — events are logged at INFO and
+  discarded. Lifecycle state intentionally `draft` to flag that the
+  V1.1+ implementation is the genuine release path. Decision #172
+  preserves in-process state at V1; persistence + analytics surface
+  lands via a dedicated story.

plm_knowledge/manifests/retrieval.bm25.yaml

@@ -0,0 +1,20 @@
+pack_id: retrieval.bm25
+kind: retrieval_bm25
+title: Retrieval — BM25 search engine
+description: BM25 (rank_bm25) search engine over PLM KnowledgeChunks loaded from 01_Dictionnaries/. Module-level singleton accessed via set_engine + get_knowledge_engine.
+version: 1.0.0
+lifecycle_state: released
+capability_id: knowledge.retrieval.bm25
+autonomy_level: supervised
+entry_module: plm_knowledge.knowledge_search_engine
+entry_callable: get_knowledge_engine
+tags:
+  - retrieval
+  - bm25
+  - search
+notes: |
+  Lifted from 02_App/backend/skills/knowledge_search_engine.py +
+  02_App/backend/skills/knowledge_pack_loader.py via git mv at Wave 6.5
+  Conv B. Re-export shims preserve legacy `skills.knowledge_*` imports
+  including the module-level singleton (set_engine + get_knowledge_engine
+  point at the canonical singleton in plm_knowledge).