Update services/kb_creation.py

services/kb_creation.py

@@ -1,22 +1,37 @@
 
-# services/kb_creation.py
+# services/kb_creation.py (DROP-IN REPLACEMENT)
+# Heading-agnostic sectioning, robust intent & module/action tagging,
+# and hybrid retrieval tuned for SOPs with variant headings (e.g.,
+# "Appointment schedule updation", "Appointment deletion").
+
 import os
 import re
 import pickle
-from typing import List, Dict, Any, Tuple, Optional
-from docx import Document
-from sentence_transformers import SentenceTransformer
-import chromadb
+from typing import TYPE_CHECKING, Any, List, Dict, Any, Tuple, Optional
+
+# During type checking (Pylance/mypy) we import a real type.
+# At runtime (or if docx is missing), we fallback to Any to avoid import issues.
+if TYPE_CHECKING:
+    from docx import Document as DocxDocument
+else:
+    DocxDocument = Any
+
+# Runtime import used for actual Document parsing (no type hints on this name).
+try:
+    from docx import Document  # noqa: F401
+except Exception:
+    Document = None  # type: ignore
+
+# These external libs are assumed to be available in your runtime.
+import chromadb  # type: ignore
+from sentence_transformers import SentenceTransformer  # type: ignore
 
-# ------------------------------ ChromaDB setup ------------------------------
 CHROMA_PATH = os.path.join(os.getcwd(), "chroma_db")
 client = chromadb.PersistentClient(path=CHROMA_PATH)
 collection = client.get_or_create_collection(name="knowledge_base")
 
-# ------------------------------ Embedding model ------------------------------
 model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
 
-# ------------------------------ BM25 (lightweight) ------------------------------
 BM25_INDEX_FILE = os.path.join(CHROMA_PATH, "bm25_index.pkl")
 bm25_docs: List[Dict[str, Any]] = []
 bm25_inverted: Dict[str, List[int]] = {}
@@ -26,21 +41,7 @@ bm25_ready: bool = False
 BM25_K1 = 1.5
 BM25_B = 0.75
 
-# ------------------------------ Utilities ------------------------------
-
-# --- Action detection helper (generic; reuses ACTION_SYNONYMS) ---
-def _line_action_tag(text: str) -> Optional[str]:
-    """
-    Return 'create'|'update'|'delete'|'navigate' if the line contains any action synonym,
-    else None. This is used to split chunks by action so creation/update/delete don't bleed
-    into one another within a single chunk.
-    """
-    low = (text or "").lower()
-    for act, syns in ACTION_SYNONYMS.items():
-        if any(s in low for s in syns):
-            return act
-    return None
-
+# --------------------------- token utilities ---------------------------
 def _tokenize(text: str) -> List[str]:
     if not text:
         return []
@@ -56,34 +57,63 @@ def _normalize_query(q: str) -> str:
 def _tokenize_meta_value(val: Optional[str]) -> List[str]:
     return _tokenize(val or "")
 
-# ------------------------------ DOCX parsing & chunking ------------------------------
-BULLET_RE = re.compile(r"^\s*(?:[\-\*\u2022]|\d+[.)])\s+", re.IGNORECASE)
+# --------------------------- DOCX parsing & chunking ---------------------------
+BULLET_RE = re.compile(r"^\s*(?:[\-\*\u2022]|\d+[\.\)])\s+", re.IGNORECASE)
+
+SECTION_KEYWORDS = (
+    "overview", "introduction", "purpose",
+    "process", "procedure", "steps", "workflow",
+    "creation", "create", "updation", "update", "edit", "change", "reschedule",
+    "delete", "deletion", "cancel", "remove",
+    "prereq", "pre-requisite", "prerequisite", "requirements",
+    "errors", "known issues", "common issues", "troubleshooting", "escalation", "permissions", "access"
+)
+
+HEADING_PATTERNS = [
+    re.compile(r"^\s*#{1,6}\s+.+$"),              # markdown-like
+    re.compile(r"^\s*[A-Z][A-Za-z0-9\s/&\-]+$"),  # Title-cased single-line
+    re.compile(r"^\s*.+:\s*$"),                   # ends with colon
+]
 
-def _split_by_sections(doc: Document) -> List[Tuple[str, List[str]]]:
+def _is_heading_text(line: str) -> bool:
+    s = (line or "").strip()
+    if not s:
+        return False
+    if (len(s) <= 140) and (not re.search(r"[.!?]$", s)):
+        low = s.lower()
+        if any(k in low for k in SECTION_KEYWORDS):
+            return True
+    return any(p.match(s) for p in HEADING_PATTERNS)
+
+def _split_by_sections(doc: DocxDocument) -> List[Tuple[str, List[str]]]:
     sections: List[Tuple[str, List[str]]] = []
-    current_title = None
+    current_title: Optional[str] = None
     current_paras: List[str] = []
-    for para in doc.paragraphs:
+
+    for para in (doc.paragraphs if hasattr(doc, "paragraphs") else []):
         text = (para.text or "").strip()
-        style_name = (para.style.name if para.style else "") or ""
-        is_heading = bool(re.match(r"Heading\s*\d+", style_name, flags=re.IGNORECASE))
-        if is_heading and text:
+        style_name = (getattr(para, "style", None).name if getattr(para, "style", None) else "") or ""
+        is_style_heading = bool(re.match(r"Heading\s*\d+", style_name, flags=re.IGNORECASE))
+        is_text_heading = _is_heading_text(text)
+
+        if (is_style_heading or is_text_heading) and text:
             if current_title or current_paras:
                 sections.append((current_title or "Untitled Section", current_paras))
-            current_title = text
+            current_title = text.rstrip(":")
             current_paras = []
         else:
             if text:
                 current_paras.append(text)
+
     if current_title or current_paras:
         sections.append((current_title or "Untitled Section", current_paras))
+
     if not sections:
-        all_text = [p.text.strip() for p in doc.paragraphs if p.text and p.text.strip()]
+        all_text = [p.text.strip() for p in getattr(doc, "paragraphs", []) if p.text and p.text.strip()]
         sections = [("Document", all_text)]
     return sections
 
 def _paragraphs_to_lines(paragraphs: List[str]) -> List[str]:
-    """Preserve bullets/numbered list lines; split long paragraphs by sentence boundaries."""
     lines: List[str] = []
     for p in (paragraphs or []):
         p = (p or "").strip()
@@ -97,74 +127,49 @@ def _paragraphs_to_lines(paragraphs: List[str]) -> List[str]:
     return lines
 
 def _chunk_text_with_context(doc_title: str, section_title: str, paragraphs: List[str], max_words: int = 160) -> List[str]:
-    """
-    Smaller chunks (~160 words), bullet-aware, and NOW action-aware.
-    We start a new chunk when:
-      - Adding the next line would exceed max_words, OR
-      - The next line starts a different action topic (create/update/delete/navigate).
-    This prevents a 'create' chunk from also containing 'update'/'delete' sentences.
-    """
     lines = _paragraphs_to_lines(paragraphs)
     chunks: List[str] = []
     current: List[str] = []
     current_len = 0
-
-    # Track the dominant action inside the current chunk (None until detected)
-    current_action: Optional[str] = None
-
     for ln in lines:
-        ln_words = ln.split()
-        ln_action = _line_action_tag(ln)  # detect line action
-
-        # If we already have an action in the current chunk and the new line switches action,
-        # or the line is a bullet heading for a different action, flush the current chunk first.
-        switch_action = (
-            (current_action is not None and ln_action is not None and ln_action != current_action)
-        )
-
-        # Hard break triggers:
-        # - size limit,
-        # - switching to a different action topic,
-        # - starting a new bullet/number while current is non-empty (keeps bullets compact).
-        if (current_len + len(ln_words) > max_words) or (switch_action) or (BULLET_RE.match(ln) and current):
+        w = ln.split()
+        if current_len + len(w) > max_words or (BULLET_RE.match(ln) and current):
             chunk = " ".join(current).strip()
             if chunk:
                 chunks.append(chunk)
-            # reset current
             current = [ln]
-            current_len = len(ln_words)
-            current_action = ln_action or None
+            current_len = len(w)
         else:
-            # Continue current chunk
             current.append(ln)
-            current_len += len(ln_words)
-            # Set the current action if not already set
-            if current_action is None and ln_action is not None:
-                current_action = ln_action
-
-    # Flush remainder
+            current_len += len(w)
     if current:
         chunk = " ".join(current).strip()
         if chunk:
             chunks.append(chunk)
-
-    # Fallback: if nothing formed, collapse all lines into one chunk
     if not chunks:
         body = " ".join(lines).strip()
         if body:
             chunks = [body]
-
     return chunks
-# ------------------------------ Intent & Module tagging ------------------------------
+
+# --------------------------- Intent & Module tagging ---------------------------
 SECTION_STEPS_HINTS = ["process steps", "procedure", "how to", "workflow", "instructions", "steps"]
-SECTION_ERRORS_HINTS = ["common errors", "resolution", "troubleshooting", "known issues", "common issues", "escalation", "escalation path", "permissions", "access"]
+SECTION_ERRORS_HINTS = [
+    "common errors", "resolution", "troubleshooting", "known issues",
+    "common issues", "escalation", "permissions", "access"
+]
+
 PERMISSION_TERMS = [
     "permission", "permissions", "access", "access right", "authorization", "authorisation",
     "role", "role access", "role mapping", "security", "security profile", "privilege", "insufficient",
     "not allowed", "not authorized", "denied", "restrict"
 ]
 ERROR_TERMS = ["error", "issue", "fail", "failure", "not working", "cannot", "can't", "mismatch", "locked", "wrong", "denied"]
-STEP_VERBS = ["navigate", "select", "scan", "verify", "confirm", "print", "move", "complete", "click", "open", "choose", "enter", "update", "save", "delete", "create", "attach", "assign"]
+STEP_VERBS = [
+    "navigate", "select", "scan", "verify", "confirm", "print", "move", "complete", "click", "open",
+    "choose", "enter", "update", "save", "delete", "create", "attach", "assign", "reschedule", "edit", "change", "cancel", "remove"
+]
+
 MODULE_VOCAB = {
     "receiving": [
         "receive", "receiving", "inbound receiving", "inbound", "goods receipt", "grn",
@@ -172,7 +177,8 @@ MODULE_VOCAB = {
     ],
     "appointments": [
         "appointment", "appointments", "schedule", "scheduling", "slot", "dock door",
-        "appointment creation", "appointment details"
+        "appointment creation", "appointment details", "appointment schedule", "reschedule",
+        "updation", "update appointment", "cancel appointment", "delete appointment"
     ],
     "picking": ["pick", "picking", "pick release", "wave", "allocation"],
     "putaway": ["putaway", "staging", "put away", "location assignment"],
@@ -181,6 +187,19 @@ MODULE_VOCAB = {
     "replenishment": ["replenishment", "replenish"],
 }
 
+ACTION_TERMS = {
+    "create": ["create", "creation", "add", "new", "generate", "tag"],
+    "update": ["update", "modify", "change", "edit", "reschedule", "re-schedule", "updation"],
+    "delete": ["delete", "remove", "cancel", "deletion", "unassign"],
+}
+
+def _action_from_text(text: str) -> Optional[str]:
+    low = (text or "").lower()
+    for act, syns in ACTION_TERMS.items():
+        if any(s in low for s in syns):
+            return act
+    return None
+
 def _infer_intent_tag(section_title: str) -> str:
     st = (section_title or "").lower()
     if any(k in st for k in SECTION_STEPS_HINTS):
@@ -191,9 +210,7 @@ def _infer_intent_tag(section_title: str) -> str:
         return "prereqs"
     if any(k in st for k in ["purpose", "overview", "introduction"]):
         return "purpose"
-    if any(k in st for k in ["inbound receiving", "receiving", "goods receipt", "grn"]):
-        return "steps"
-    if any(k in st for k in ["appointment", "appointments", "schedule", "scheduling"]):
+    if any(k in st for k in ["inbound receiving", "receiving", "goods receipt", "grn", "appointment", "schedule", "scheduling"]):
         return "steps"
     return "neutral"
 
@@ -203,8 +220,8 @@ def _derive_semantic_intent_from_text(text: str) -> Tuple[str, List[str]]:
     intent = "neutral"
     if any(term in t for term in PERMISSION_TERMS):
         intent = "errors"; tags.append("permissions")
-        if "role" in t: tags.append("role_access")
-        if "security" in t: tags.append("security")
+    if "role" in t: tags.append("role_access")
+    if "security" in t: tags.append("security")
     if intent == "neutral" and any(term in t for term in ERROR_TERMS):
         intent = "errors"; tags.append("errors")
     if intent == "neutral" and any(v in t for v in STEP_VERBS):
@@ -226,7 +243,7 @@ def _derive_module_tags(text: str, filename: str, section_title: str) -> List[st
             found = ["appointments"]
     return list(sorted(set(found)))
 
-# ------------------------------ Ingestion ------------------------------
+# --------------------------- Ingestion ---------------------------
 def ingest_documents(folder_path: str) -> None:
     print(f"[KB] Checking folder: {folder_path}")
     files = [f for f in os.listdir(folder_path) if f.lower().endswith('.docx')]
@@ -242,13 +259,16 @@ def ingest_documents(folder_path: str) -> None:
     for file in files:
         file_path = os.path.join(folder_path, file)
         doc_title = os.path.splitext(file)[0]
-        doc = Document(file_path)
+        doc = Document(file_path)  # runtime use; type hints use DocxDocument alias
         sections = _split_by_sections(doc)
         total_chunks = 0
+
         for s_idx, (section_title, paras) in enumerate(sections):
             chunks = _chunk_text_with_context(doc_title, section_title, paras, max_words=160)
             total_chunks += len(chunks)
             base_intent = _infer_intent_tag(section_title)
+            section_action = _action_from_text(section_title)
+
             for c_idx, chunk in enumerate(chunks):
                 derived_intent, topic_tags = _derive_semantic_intent_from_text(chunk)
                 final_intent = base_intent
@@ -256,12 +276,8 @@ def ingest_documents(folder_path: str) -> None:
                     final_intent = "errors"
                 elif base_intent == "neutral" and derived_intent in ("steps", "prereqs"):
                     final_intent = derived_intent
+
                 module_tags = _derive_module_tags(chunk, file, section_title)
-                # Fallback: appointment chunks marked as steps when neutral (existing patch)
-                if final_intent == "neutral" and ("appointments" in module_tags):
-                   final_intent = "steps"
-    # >>> NEW: annotate chunk with action tags (create/update/delete/navigate)
-                actions_here = _extract_actions(chunk)  # reuse ACTION_SYNONYMS
                 embedding = model.encode(chunk).tolist()
                 doc_id = f"{file}:{s_idx}:{c_idx}"
                 meta = {
@@ -273,7 +289,7 @@ def ingest_documents(folder_path: str) -> None:
                     "intent_tag": final_intent,
                     "topic_tags": ", ".join(topic_tags) if topic_tags else "",
                     "module_tags": ", ".join(module_tags) if module_tags else "",
-                    "action_tags": ", ".join(actions_here) if actions_here else "",
+                    "action_tag": section_action or _action_from_text(chunk) or "",
                 }
                 try:
                     collection.add(ids=[doc_id], embeddings=[embedding], documents=[chunk], metadatas=[meta])
@@ -303,11 +319,14 @@ def ingest_documents(folder_path: str) -> None:
                     if term not in seen:
                         bm25_df[term] = bm25_df.get(term, 0) + 1
                         seen.add(term)
+
         print(f"[KB] Ingested {file} → {total_chunks} chunks")
+
     N = len(bm25_docs)
     if N > 0:
         bm25_avgdl = sum(d["length"] for d in bm25_docs) / float(N)
         bm25_ready = True
+
     payload = {
         "bm25_docs": bm25_docs,
         "bm25_inverted": bm25_inverted,
@@ -322,7 +341,7 @@ def ingest_documents(folder_path: str) -> None:
     print(f"[KB] BM25 index saved: {BM25_INDEX_FILE}")
     print(f"[KB] Documents ingested. Total entries in Chroma: {collection.count()}")
 
-# ------------------------------ BM25 load ------------------------------
+# --------------------------- BM25 load ---------------------------
 def _load_bm25_index() -> None:
     global bm25_docs, bm25_inverted, bm25_df, bm25_avgdl, bm25_ready
     if not os.path.exists(BM25_INDEX_FILE):
@@ -342,7 +361,7 @@ def _load_bm25_index() -> None:
 
 _load_bm25_index()
 
-# ------------------------------ BM25 search ------------------------------
+# --------------------------- BM25 search ---------------------------
 def _bm25_score_for_doc(query_terms: List[str], doc_idx: int) -> float:
     if not bm25_ready or doc_idx < 0 or doc_idx >= len(bm25_docs):
         return 0.0
@@ -388,18 +407,18 @@ def bm25_search(query: str, top_k: int = 50) -> List[Tuple[int, float]]:
     scored.sort(key=lambda x: x[1], reverse=True)
     return scored[:top_k]
 
-# ------------------------------ Semantic-only ------------------------------
+# --------------------------- Semantic-only ---------------------------
 def search_knowledge_base(query: str, top_k: int = 10) -> dict:
     query_embedding = model.encode(query).tolist()
     res = collection.query(
         query_embeddings=[query_embedding],
         n_results=top_k,
-        include=['documents', 'metadatas', 'distances']  # no 'ids'
+        include=['documents', 'metadatas', 'distances']
     )
-    documents = (res.get("documents", [[]]) or [[]])[0]
-    metadatas = (res.get("metadatas", [[]]) or [[]])[0]
-    distances = (res.get("distances", [[]]) or [[]])[0]
-    # Synthesize IDs from metadata (filename:section:chunk_index)
+    documents = (res.get("documents", [[""]]) or [[""]])[0]
+    metadatas = (res.get("metadatas", [[{}]]) or [[{}]])[0]
+    distances = (res.get("distances", [[None]]) or [[None]])[0]
+
     ids: List[str] = []
     if documents:
         synthesized = []
@@ -417,13 +436,14 @@ def search_knowledge_base(query: str, top_k: int = 10) -> dict:
         "ids": ids,
     }
 
-# ------------------------------ Hybrid search (generic + intent-aware) ------------------------------
+# --------------------------- Hybrid search (generic + intent-aware) -----------
 ACTION_SYNONYMS = {
-    "create": ["create", "creation", "add", "new", "generate"],
-    "update": ["update", "modify", "change", "edit"],
-    "delete": ["delete", "remove"],
+    "create": ["create", "creation", "add", "new", "generate", "tag"],
+    "update": ["update", "modify", "change", "edit", "reschedule", "re-schedule", "updation"],
+    "delete": ["delete", "remove", "cancel", "deletion", "unassign"],
     "navigate": ["navigate", "go to", "open"],
 }
+
 ERROR_INTENT_TERMS = [
     "error", "issue", "fail", "not working", "resolution", "fix",
     "permission", "permissions", "access", "no access", "authorization", "authorisation",
@@ -498,11 +518,11 @@ def _intent_weight(meta: dict, user_intent: str) -> float:
     topics = (meta or {}).get("topic_tags", "") or ""
     topic_list = [t.strip() for t in topics.split(",") if t.strip()]
     if user_intent == "errors" and (
-        any(k in st for k in ["common errors", "known issues", "common issues", "errors", "escalation", "permissions", "access"])
-        or ("permissions" in topic_list)
+        any(k in st for k in ["common errors", "known issues", "common issues", "errors", "escalation", "permissions", "access"]) or
+        ("permissions" in topic_list)
     ):
         return 1.10
-    if user_intent == "steps" and any(k in st for k in ["process steps", "procedure", "instructions", "workflow"]):
+    if user_intent == "steps" and any(k in st for k in ["process steps", "procedure", "instructions", "workflow", "creation", "updation", "deletion"]):
         return 0.75
     return -0.2
 
@@ -512,7 +532,8 @@ def _meta_overlap(meta: Dict[str, Any], q_terms: List[str]) -> float:
     section_tokens = _tokenize_meta_value(meta.get("section"))
     topic_tokens = _tokenize_meta_value((meta.get("topic_tags") or ""))
     module_tokens = _tokenize_meta_value((meta.get("module_tags") or ""))
-    meta_tokens = set(fn_tokens + title_tokens + section_tokens + topic_tokens + module_tokens)
+    action_token = _tokenize_meta_value((meta.get("action_tag") or ""))
+    meta_tokens = set(fn_tokens + title_tokens + section_tokens + topic_tokens + module_tokens + action_token)
     if not meta_tokens or not q_terms:
         return 0.0
     qset = set(q_terms)
@@ -552,17 +573,12 @@ def _literal_query_match_boost(text: str, query_norm: str) -> float:
     return min(boost, 1.6)
 
 def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6, beta: float = 0.4) -> dict:
-    """
-    Hybrid retrieval (embeddings + BM25) with intent-, action-, module-, and phrase-aware reranking.
-    Returns top items plus doc-level prior and intent for downstream formatting.
-    """
     norm_query = _normalize_query(query)
     q_terms = _tokenize(norm_query)
     user_intent = _detect_user_intent(query)
     actions = _extract_actions(query)
     user_modules = _extract_modules_from_query(query)
 
-    # semantic (embeddings) search via Chroma
     sem_res = search_knowledge_base(norm_query, top_k=max(top_k, 40))
     sem_docs = sem_res.get("documents", [])
     sem_metas = sem_res.get("metadatas", [])
@@ -576,9 +592,9 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
             return 1.0 / (1.0 + float(d))
         except Exception:
             return 0.0
+
     sem_sims = [dist_to_sim(d) for d in sem_dists]
 
-    # BM25 search
     bm25_hits = bm25_search(norm_query, top_k=max(80, top_k * 6))
     bm25_max = max([s for _, s in bm25_hits], default=1.0)
     bm25_norm_pairs = [(idx, (score / bm25_max) if bm25_max > 0 else 0.0) for idx, score in bm25_hits]
@@ -589,22 +605,23 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
         bm25_id_to_text[d["id"]] = d["text"]
         bm25_id_to_meta[d["id"]] = d["meta"]
 
-    # union of candidate IDs (semantic + bm25)
     union_ids = set(sem_ids) | set(bm25_id_to_norm.keys())
 
-    # weights
-    gamma = 0.30  # meta overlap
-    delta = 0.55  # intent boost
-    epsilon = 0.30  # action weight
-    zeta = 0.65  # module weight
-    eta = 0.50  # phrase-level boost
-    theta = 0.00  # optional heading alignment bonus not used
-    iota = 0.60  # literal query match boost
+    gamma = 0.30
+    delta = 0.55
+    epsilon = 0.35
+    zeta = 0.65
+    eta = 0.50
+    iota = 0.60
 
-    combined_records_ext: List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float, float]] = []
+    def _action_meta_bonus(meta: Dict[str, Any], actions: List[str]) -> float:
+        if not actions:
+            return 0.0
+        act = (meta or {}).get("action_tag", "") or ""
+        return 0.6 if act and act in actions else 0.0
 
+    combined_records_ext: List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float]] = []
     for cid in union_ids:
-        # pick semantic fields if present; fallback to bm25
         if cid in sem_ids:
             pos = sem_ids.index(cid)
             sem_sim = sem_sims[pos] if pos < len(sem_sims) else 0.0
@@ -613,17 +630,16 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
             sem_meta = sem_metas[pos] if pos < len(sem_metas) else {}
         else:
             sem_sim, sem_dist, sem_text, sem_meta = 0.0, None, "", {}
-
         bm25_sim = bm25_id_to_norm.get(cid, 0.0)
         bm25_text = bm25_id_to_text.get(cid, "")
         bm25_meta = bm25_id_to_meta.get(cid, {})
-
         text = sem_text if sem_text else bm25_text
         meta = sem_meta if sem_meta else bm25_meta
 
         m_overlap = _meta_overlap(meta, q_terms)
         intent_boost = _intent_weight(meta, user_intent)
         act_wt = _action_weight(text, actions)
+        act_meta = _action_meta_bonus(meta, actions)
         mod_wt = _module_weight(meta, user_modules)
         phrase_wt = _phrase_boost_score(text, q_terms)
         literal_wt = _literal_query_match_boost(text, norm_query)
@@ -633,52 +649,30 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
             + beta * bm25_sim
             + gamma * m_overlap
             + delta * intent_boost
-            + epsilon * act_wt
+            + epsilon * (act_wt + act_meta)
             + zeta * mod_wt
             + eta * phrase_wt
-            + theta * 0.0
             + iota * literal_wt
         )
         combined_records_ext.append(
-            (cid, final_score, (sem_dist if sem_dist is not None else 999.0), text, meta,
-             m_overlap, intent_boost, act_wt, mod_wt, phrase_wt, 0.0, literal_wt)
+            (cid, final_score, (sem_dist if sem_dist is not None else 999.0), text, meta, m_overlap, intent_boost, act_wt + act_meta, mod_wt, phrase_wt, literal_wt)
         )
 
-    # exact-match rerank for errors (push lines containing query phrases)
-    if user_intent == "errors":
-        exact_hits = []
-        toks = [tok for tok in norm_query.split() if len(tok) > 2]
-        bigrams = _make_ngrams(toks, 2)
-        for rec in combined_records_ext:
-            text_lower = (rec[3] or "").lower()
-            if norm_query and norm_query in text_lower:
-                exact_hits.append(rec)
-                continue
-            if any(bg in text_lower for bg in bigrams):
-                exact_hits.append(rec)
-        if exact_hits:
-            rest = [r for r in combined_records_ext if r not in exact_hits]
-            exact_hits.sort(key=lambda x: x[1], reverse=True)
-            rest.sort(key=lambda x: x[1], reverse=True)
-            combined_records_ext = exact_hits + rest
-
-    # doc-level prior: prefer docs with more aligned chunks
     from collections import defaultdict as _dd
-    doc_groups: Dict[str, List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float, float]]] = _dd(list)
+    doc_groups: Dict[str, List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float]]] = _dd(list)
     for rec in combined_records_ext:
         meta = rec[4] or {}
         fn = meta.get("filename", "unknown")
         doc_groups[fn].append(rec)
 
-    def doc_prior(recs: List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float, float]]) -> float:
+    def doc_prior(recs: List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float]]) -> float:
         total_score = sum(r[1] for r in recs)
         total_overlap = sum(r[5] for r in recs)
         total_intent = sum(max(0.0, r[6]) for r in recs)
         total_action = sum(max(0.0, r[7]) for r in recs)
         total_module = sum(r[8] for r in recs)
         total_phrase = sum(r[9] for r in recs)
-        total_literal = sum(r[11] for r in recs)
-        total_penalty = sum(min(0.0, r[6]) for r in recs) + sum(min(0.0, r[7]) for r in recs)
+        total_literal = sum(r[10] for r in recs)
         errors_section_bonus = 0.0
         if any("error" in ((r[4] or {}).get("section", "")).lower() or
                "known issues" in ((r[4] or {}).get("section", "")).lower() or
@@ -688,12 +682,11 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
             total_score
             + 0.4 * total_overlap
             + 0.7 * total_intent
-            + 0.5 * total_action
+            + 0.55 * total_action
             + 0.8 * total_module
             + 0.6 * total_phrase
             + 0.7 * total_literal
             + errors_section_bonus
-            + 0.3 * total_penalty
         )
 
     best_doc, best_doc_prior = None, -1.0
@@ -703,7 +696,7 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
             best_doc_prior, best_doc = p, fn
 
     best_recs = sorted(doc_groups.get(best_doc, []), key=lambda x: x[1], reverse=True)
-    other_recs: List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float, float]] = []
+    other_recs: List[Tuple[str, float, float, str, Dict[str, Any], float, float, float, float, float, float]] = []
     for fn, recs in doc_groups.items():
         if fn == best_doc:
             continue
@@ -730,7 +723,7 @@ def hybrid_search_knowledge_base(query: str, top_k: int = 10, alpha: float = 0.6
         "actions": actions,
     }
 
-# ------------------------------ Section fetch helpers ------------------------------
+# --------------------------- Section fetch helpers ---------------------------
 def get_section_text(filename: str, section: str) -> str:
     texts: List[str] = []
     for d in bm25_docs:
@@ -766,7 +759,6 @@ def get_best_errors_section_text(filename: str) -> str:
             or "access" in sec
             or "known issues" in sec
             or "common issues" in sec
-            or "errors" in sec
             or ("permissions" in topic_list)
         ):
             t = (d.get("text") or "").strip()
@@ -775,10 +767,6 @@ def get_best_errors_section_text(filename: str) -> str:
     return "\n\n".join(texts).strip()
 
 def get_escalation_text(filename: str) -> str:
-    """
-    Return concatenated text from any 'Escalation' section in the given SOP file.
-    Works across future SOPs—only relies on the heading name containing 'escalation'.
-    """
     texts: List[str] = []
     for d in bm25_docs:
         m = d.get("meta", {})
@@ -790,7 +778,6 @@ def get_escalation_text(filename: str) -> str:
                     texts.append(t)
     return "\n\n".join(texts).strip()
 
-# ------------------------------ Admin helpers ------------------------------
 def get_kb_runtime_info() -> Dict[str, Any]:
     return {
         "chroma_path": CHROMA_PATH,