Update main.py

main.py

@@ -1,4 +1,5 @@
 
+# main.py
 import os
 import json
 import re
@@ -12,8 +13,9 @@ from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from dotenv import load_dotenv
+from difflib import SequenceMatcher
 
-# Import KB services
+# KB services
 from services.kb_creation import (
     collection,
     ingest_documents,
@@ -28,10 +30,9 @@ from services.kb_creation import (
 from services.login import router as login_router
 from services.generate_ticket import get_valid_token, create_incident
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # Environment
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 load_dotenv()
 VERIFY_SSL = os.getenv("SERVICENOW_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
 GEMINI_SSL_VERIFY = os.getenv("GEMINI_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
@@ -42,17 +43,15 @@ GEMINI_URL = (
 )
 os.environ["POSTHOG_DISABLED"] = "true"
 
-
 def safe_str(e: Any) -> str:
     try:
         return builtins.str(e)
     except Exception:
         return "<error stringify failed>"
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # App / Lifespan
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     try:
@@ -66,14 +65,13 @@ async def lifespan(app: FastAPI):
         print(f"[KB] ingestion failed: {safe_str(e)}")
     yield
 
-
 app = FastAPI(lifespan=lifespan)
 app.include_router(login_router)
 
-# Allow your HF Space frontend; add localhost for local dev if needed
+# CORS
 origins = [
     "https://chatbotnova-chatbot-frontend.hf.space",
-    # "http://localhost:5173",  # uncomment for local dev (Vite)
+    # "http://localhost:5173",  # local dev if needed
 ]
 app.add_middleware(
     CORSMiddleware,
@@ -83,31 +81,26 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # Models
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 class ChatInput(BaseModel):
     user_message: str
     prev_status: Optional[str] = None
     last_issue: Optional[str] = None
 
-
 class IncidentInput(BaseModel):
     short_description: str
     description: str
     mark_resolved: Optional[bool] = False
 
-
 class TicketDescInput(BaseModel):
     issue: str
 
-
 class TicketStatusInput(BaseModel):
     sys_id: Optional[str] = None
     number: Optional[str] = None
 
-
 STATE_MAP = {
     "1": "New",
     "2": "In Progress",
@@ -117,19 +110,16 @@ STATE_MAP = {
     "8": "Canceled",
 }
 
-
-# ------------------------------------------------------------------------------
-# Generic helpers
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
+# Generic helpers (shared)
+# ---------------------------------------------------------------------
 NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()  # 'digit' or 'step'
-
 DOMAIN_STATUS_TERMS = (
     "shipment", "order", "load", "trailer", "wave",
     "inventory", "putaway", "receiving", "appointment",
     "dock", "door", "manifest", "pallet", "container",
     "asn", "grn", "pick", "picking"
 )
-
 ERROR_FAMILY_SYNS = {
     "NOT_FOUND": (
         "not found", "missing", "does not exist", "doesn't exist",
@@ -159,7 +149,6 @@ ERROR_FAMILY_SYNS = {
     ),
 }
 
-
 def _detect_error_families(msg: str) -> list:
     low = (msg or "").lower()
     low_norm = re.sub(r"[^\w\s]", " ", low)
@@ -170,13 +159,11 @@ def _detect_error_families(msg: str) -> list:
             fams.append(fam)
     return fams
 
-
 def _is_domain_status_context(msg_norm: str) -> bool:
     if "status locked" in msg_norm or "locked status" in msg_norm:
         return True
     return any(term in msg_norm for term in DOMAIN_STATUS_TERMS)
 
-
 def _normalize_lines(text: str) -> List[str]:
     raw = (text or "")
     try:
@@ -184,23 +171,14 @@ def _normalize_lines(text: str) -> List[str]:
     except Exception:
         return [raw.strip()] if raw.strip() else []
 
-
-# --- NEW: action-aware filter for numbered steps (creation/update/delete) ---
-def _filter_numbered_steps_by_actions(numbered_text: str,
-                                      wanted: set[str],
-                                      exclude: set[str]) -> str:
-    """
-    Keep only lines that match the 'wanted' actions and drop lines that match 'exclude'.
-    Works on already-numbered/bulleted text (one step per line).
-    """
-    # Keep synonyms aligned with kb_creation.ACTION_SYNONYMS
+# ---------------- Action filters for steps (create/update/delete) ----------------
+def _filter_numbered_steps_by_actions(numbered_text: str, wanted: set[str], exclude: set[str]) -> str:
     ACTION_SYNONYMS = {
         "create": ("create", "creation", "add", "new", "generate"),
         "update": ("update", "modify", "change", "edit"),
         "delete": ("delete", "remove"),
         "navigate": ("navigate", "go to", "open"),
     }
-
     def _has_any(line: str, keys: set[str]) -> bool:
         low = (line or "").lower()
         for k in keys:
@@ -211,142 +189,42 @@ def _filter_numbered_steps_by_actions(numbered_text: str,
 
     out_lines = []
     for ln in (numbered_text or "").splitlines():
-        # If an exclude action appears in the line, drop it
         if _has_any(ln, exclude):
             continue
-        # If caller asked for specific actions, keep only those
         if wanted:
             if _has_any(ln, wanted):
                 out_lines.append(ln)
         else:
-            # no explicit wanted actions → keep as-is
             out_lines.append(ln)
-
-    # If over-filtering made it empty, fall back to original text
     return "\n".join(out_lines).strip() or (numbered_text or "").strip()
 
-# --- NEW: extract the anchor clause from user message ---
-def _extract_anchor_from_query(msg: str) -> dict:
-    """
-    Split user message into:
-      - 'anchor': the clause we should match against SOP steps.
-      - 'has_followup': True when user is clearly asking what comes next (what next, what to do, then).
-    Works across any SOP text; no domain words required.
-    """
-    raw = (msg or "").strip()
-    low = _norm_text(raw)
-
-    # very small set of generic follow-up cues (no domain synonyms)
-    FOLLOWUP_CUES = ("what next", "what is next", "what to do", "then", "after that", "next")
-
-    has_followup = any(cue in low for cue in FOLLOWUP_CUES)
-
-    # Split by common separators to isolate the anchor clause
-    parts = [p.strip() for p in re.split(r"[?.,;:\-\n]+", raw) if p.strip()]
-    if not parts:
-        return {"anchor": raw, "has_followup": has_followup}
-
-    # If a follow-up cue is in the last part, prefer the preceding part as the anchor
-    last = parts[-1]
-    last_low = _norm_text(last)
-    if any(cue in last_low for cue in FOLLOWUP_CUES) and len(parts) >= 2:
-        anchor = parts[-2]
-    else:
-        anchor = parts[0] if len(parts) == 1 else parts[-1]  # favor the end if user writes "... , then what next"
-
-    return {"anchor": anchor.strip(), "has_followup": has_followup}
-
-# --- Core: keyword-free, anchor-based "next steps" ---
-def _anchor_next_steps(user_message: str, numbered_text: str, max_next: int = 8) -> list | None:
-    """
-    Locate the step line (or sentence inside it) that best matches the user's anchor clause,
-    then return ONLY subsequent steps (renumbered by caller). Returns None if no strong anchor is found.
-    """
-
-    steps = _split_sop_into_steps(numbered_text)
-    if not steps:
-        return None
-
-    info = _extract_anchor_from_query(user_message)
-    anchor = info.get("anchor", "").strip()
-    if not anchor:
-        return None
-    anchor_norm = _norm_text(anchor)
-    has_followup = bool(info.get("has_followup"))
-
-    best_idx, best_score, best_literal = -1, -1.0, False
-    candidate_indices = []
-
-    for idx, step_line in enumerate(steps):
-        # Score on full line
-        s_full = _similarity(anchor, step_line)
-        literal_hit = False
-        sent_scores = [s_full]
-
-        # Also score each sentence within this step (to match middle sentences)
-        for s in _split_sentences(step_line):
-            sent_scores.append(_similarity(anchor, s))
-            # literal containment (punctuation-insensitive)
-            a_flat = re.sub(r"\W+", "", anchor_norm)
-            s_flat = re.sub(r"\W+", "", _norm_text(s))
-            if a_flat and (a_flat in s_flat or s_flat in a_flat):
-                literal_hit = True
-
-        score = max(sent_scores)
-        candidate_indices.append((idx, score, literal_hit))
-
-    # Choose best; for near ties prefer later index (progress assumption)
-    candidate_indices.sort(key=lambda t: (t[1], t[0]), reverse=True)
-    best_idx, best_score, best_literal = candidate_indices[0]
-
-    # Dynamic threshold:
-    # - literal containment → accept
-    # - follow-up cue → lower threshold (e.g., 0.50)
-    # - otherwise require a modest similarity
-    tok_count = len([t for t in anchor_norm.split() if len(t) > 1])
-
-    if best_literal:
-        accept = True
-    else:
-        base_ok = best_score >= (0.55 if not has_followup else 0.50)
-        len_ok = (best_score >= 0.40) and (tok_count >= 3)
-        accept = base_ok or len_ok
-
-    if not accept:
-        return None
-
-    # Start from the step AFTER the matched one
-    start = best_idx + 1
-    if start >= len(steps):
-        return []  # already at final step
-    end = min(start + max_next, len(steps))
-    next_steps = steps[start:end]
-
-    # Dedupe just in case adjacent chunks contain repeated lines
-    # (use the same numbering by caller)
-    return [ln for ln in _dedupe_lines("\n".join(next_steps)).splitlines() if ln.strip()]
-
+# ---------------- Small utilities used by next-step & filtering ----------------
+def _dedupe_lines(text: str) -> str:
+    seen, out = set(), []
+    for ln in (text or "").splitlines():
+        key = re.sub(r"\s+", " ", (ln or "").strip().lower())
+        if key and key not in seen:
+            out.append(ln)
+            seen.add(key)
+    return "\n".join(out).strip()
+
+def _split_sentences(block: str) -> list:
+    parts = [t.strip() for t in re.split(r"(?<=[.!?])\s+", block or "") if t.strip()]
+    return parts if parts else ([block.strip()] if (block or "").strip() else [])
+
+# ------------- Numbering + text normalization used elsewhere ----------
 def _ensure_numbering(text: str) -> str:
-    """
-    Normalize raw SOP steps into a clean numbered list using circled digits.
-    Robust against '1.', '1)', 'Step 1:', bullets ('-', '*', '•'), and circled digits.
-    """
     text = re.sub(r"[\u2060\u200B]", "", text or "")
     lines = [ln.strip() for ln in (text or "").splitlines() if ln and ln.strip()]
     if not lines:
         return text or ""
-
     para = " ".join(lines).strip()
     if not para:
         return ""
-
-    # Hard breaks at step boundaries
-    para_clean = re.sub(r"(?:\b\d+\s*[.\)])\s+", "\n\n\n", para)          # 1. / 1)
-    para_clean = re.sub(r"(?:[\u2460-\u2473]\s+)", "\n\n\n", para_clean)  # circled digits
-    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:\s*", "\n\n\n", para_clean) # Step 1:
-
+    para_clean = re.sub(r"(?:\b\d+\s*[.\)])\s+", "\n\n\n", para)
+    para_clean = re.sub(r"(?:[\u2460-\u2473]\s+)", "\n\n\n", para_clean)
+    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:\s*", "\n\n\n", para_clean)
     segments = [seg.strip() for seg in para_clean.split("\n\n\n") if seg.strip()]
-
     if len(segments) < 2:
         tmp = [ln.strip() for ln in para.splitlines() if ln.strip()]
         segments = tmp if len(tmp) > 1 else [seg.strip() for seg in re.split(r"(?<=[.!?])\s+", para) if seg.strip()]
@@ -354,51 +232,36 @@ def _ensure_numbering(text: str) -> str:
     def strip_prefix_any(s: str) -> str:
         return re.sub(
             r"^\s*(?:"
-            r"(?:\d+\s*[.\)])"      # leading numbers 1., 2)
-            r"|(?:step\s*\d+:?)"    # Step 1:
-            r"|(?:[-*\u2022])"      # bullets
-            r"|(?:[\u2460-\u2473])" # circled digits
-            r")\s*",
-            "",
-            (s or "").strip(),
-            flags=re.IGNORECASE
+            r"(?:\d+\s*[.\)])|"        # 1. / 1)
+            r"(?i:step\s*\d+:?)|"      # Step 1:
+            r"(?:[-*\u2022])|"         # bullets
+            r"(?:[\u2460-\u2473])"     # circled digits
+            r")\s*", "", (s or "").strip()
         )
-
     clean_segments = [strip_prefix_any(seg) for seg in segments if seg.strip()]
-
     circled = {
         1: "\u2460", 2: "\u2461", 3: "\u2462", 4: "\u2463", 5: "\u2464",
         6: "\u2465", 7: "\u2466", 8: "\u2467", 9: "\u2468", 10: "\u2469",
         11: "\u246a", 12: "\u246b", 13: "\u246c", 14: "\u246d", 15: "\u246e",
         16: "\u246f", 17: "\u2470", 18: "\u2471", 19: "\u2472", 20: "\u2473"
     }
-
     out = []
     for idx, seg in enumerate(clean_segments, start=1):
         marker = circled.get(idx, f"{idx})")
         out.append(f"{marker} {seg}")
-
     return "\n".join(out)
 
 def _norm_text(s: str) -> str:
-    """
-    Normalize text: lower, remove punctuation, light stemming for common verb endings
-    and plural 's'. (scan/scanned/scanning -> scan; confirm/confirming -> confirm)
-    """
     s = (s or "").lower()
     s = re.sub(r"[^\w\s]", " ", s)
     s = re.sub(r"\s+", " ", s).strip()
     if not s:
         return s
-
-    # crude token-level stemming (safe for English verbs/nouns seen in SOPs)
     toks = s.split()
     stemmed = []
     for t in toks:
-        # strip plural 's' unless token is very short
         if len(t) > 3 and t.endswith("s"):
             t = t[:-1]
-        # past tense/gerund
         if len(t) > 4 and t.endswith("ed"):
             t = t[:-2]
         if len(t) > 5 and t.endswith("ing"):
@@ -406,17 +269,12 @@ def _norm_text(s: str) -> str:
         stemmed.append(t)
     return " ".join(stemmed).strip()
 
-
 def _split_sop_into_steps(numbered_text: str) -> list:
-    """
-    Split a numbered/bulleted SOP block (already passed through _ensure_numbering)
-    into atomic steps. Returns a list of raw step strings (order preserved).
-    """
     lines = [ln.strip() for ln in (numbered_text or "").splitlines() if ln.strip()]
     steps = []
     for ln in lines:
         cleaned = re.sub(
-            r"^\s*(?:[\u2460-\u2473]|\d+[.\)]|[-*•])\s*",
+            r"^\s*(?:[\u2460-\u2473]|\d+[.)]|[-*•])\s*",
             "",
             ln
         )
@@ -424,186 +282,84 @@ def _split_sop_into_steps(numbered_text: str) -> list:
             steps.append(cleaned)
     return steps
 
-def _soft_match_score(a: str, b: str) -> float:
-    """
-    Fuzzy match score using stemmed tokens + bigram overlap.
-    Returns 0..1 (higher is more similar).
-    """
-    a_norm = _norm_text(a)
-    b_norm = _norm_text(b)
-    ta = set(a_norm.split())
-    tb = set(b_norm.split())
-    if not ta or not tb:
-        return 0.0
-
-    # token Jaccard
+# ---------------- Similarity for anchor-based next steps ----------------
+def _similarity(a: str, b: str) -> float:
+    a_norm, b_norm = _norm_text(a), _norm_text(b)
+    ta, tb = set(a_norm.split()), set(b_norm.split())
     inter = len(ta & tb)
-    union = len(ta | tb)
-    jacc = inter / union if union else 0.0
-
-    # bigrams
-    def _bigrams(tokens: List[str]) -> set:
+    union = len(ta | tb) or 1
+    jacc = inter / union
+    def _bigrams(tokens: list) -> set:
         return set([" ".join(tokens[i:i+2]) for i in range(len(tokens)-1)]) if len(tokens) > 1 else set()
-    ab = _bigrams(a_norm.split())
-    bb = _bigrams(b_norm.split())
-    bigram_inter = len(ab & bb)
-    bigram_union = len(ab | bb) if (ab or bb) else 1
-    big = bigram_inter / bigram_union
-
-    # combine (weights tuned to prefer phrase overlaps slightly)
-    return min(1.0, 0.65 * jacc + 0.45 * big)
-
-def _detect_next_intent(user_query: str) -> bool:
-    q = _norm_text(user_query)
-    keys = [
-        "after", "after this", "what next", "whats next", "next step",
-        "then what", "following step", "continue", "subsequent", "proceed"
-    ]
-    return any(k in q for k in keys)
-
-    
-
-def _resolve_next_steps(user_query: str, numbered_text: str, max_next: int = 8, min_score: float = 0.25):
-    """
-    Robust next-step resolver:
-    1) Detect 'what next' intent.
-    2) Stem & match query against each step using tokens + bigrams + synonyms.
-    3) If a good anchor is found, return ONLY subsequent steps (window=max_next).
-       Else return None (fallback to full SOP rendering).
-    """
-    if not _detect_next_intent(user_query):
-        return None
+    ab, bb = _bigrams(a_norm.split()), _bigrams(b_norm.split())
+    big_inter = len(ab & bb)
+    big_union = len(ab | bb) or 1
+    big = big_inter / big_union
+    char = SequenceMatcher(None, a_norm, b_norm).ratio()
+    return min(1.0, 0.45*jacc + 0.30*big + 0.35*char)
+
+def _extract_anchor_from_query(msg: str) -> dict:
+    raw = (msg or "").strip()
+    low = _norm_text(raw)
+    FOLLOWUP_CUES = ("what next", "what is next", "what to do", "then", "after that", "next")
+    has_followup = any(cue in low for cue in FOLLOWUP_CUES)
+    parts = [p.strip() for p in re.split(r"[?.,;:\-\n]+", raw) if p.strip()]
+    if not parts:
+        return {"anchor": raw, "has_followup": has_followup}
+    last = parts[-1]
+    last_low = _norm_text(last)
+    if any(cue in last_low for cue in FOLLOWUP_CUES) and len(parts) >= 2:
+        anchor = parts[-2]
+    else:
+        anchor = parts[-1] if len(parts) > 1 else parts[0]
+    return {"anchor": anchor.strip(), "has_followup": has_followup}
 
+def _anchor_next_steps(user_message: str, numbered_text: str, max_next: int = 8) -> list | None:
     steps = _split_sop_into_steps(numbered_text)
     if not steps:
         return None
+    info = _extract_anchor_from_query(user_message)
+    anchor = info.get("anchor", "").strip()
+    if not anchor:
+        return None
+    anchor_norm = _norm_text(anchor)
+    has_followup = bool(info.get("has_followup"))
 
-    q_norm = _norm_text(user_query)
-    q_tokens = [t for t in q_norm.split() if len(t) > 1]
+    candidates = []
+    for idx, step_line in enumerate(steps):
+        s_full = _similarity(anchor, step_line)
+        literal_hit = False
+        scores = [s_full]
+        for s in _split_sentences(step_line):
+            scores.append(_similarity(anchor, s))
+            a_flat = re.sub(r"\W+", "", anchor_norm)
+            s_flat = re.sub(r"\W+", "", _norm_text(s))
+            if a_flat and (a_flat in s_flat or s_flat in a_flat):
+                literal_hit = True
+        score = max(scores)
+        candidates.append((idx, score, literal_hit))
 
-    best_idx, best_score = -1, -1.0
-    for idx, step in enumerate(steps):
-        # base fuzzy score
-        s1 = _soft_match_score(user_query, step)
-        # synonym hits
-        syn = _syn_hits(q_tokens, step)
-        # combined score (synonyms are discrete)
-        score = s1 + 0.12 * syn
-        if score > best_score:
-            best_score, best_idx = score, idx
+    candidates.sort(key=lambda t: (t[1], t[0]), reverse=True)
+    best_idx, best_score, best_literal = candidates[0]
 
-    # Looser threshold to accept anchors with synonyms / tense differences
-    if best_idx < 0 or best_score < min_score:
-        return None  # let caller fall back to the full SOP
+    tok_count = len([t for t in anchor_norm.split() if len(t) > 1])
+    if best_literal:
+        accept = True
+    else:
+        base_ok = best_score >= (0.55 if not has_followup else 0.50)
+        len_ok  = (best_score >= 0.40) and (tok_count >= 3)
+        accept  = base_ok or len_ok
+    if not accept:
+        return None
 
     start = best_idx + 1
     if start >= len(steps):
-        return []  # already at final step
-
+        return []
     end = min(start + max_next, len(steps))
-    return steps[start:end]
-
-def _syn_hits(q_tokens: List[str], step_line: str) -> int:
-    """
-    Synonym/alias hits tailored for WMS picking language.
-    Ex: 'scanned location' ~ 'prompt location' ~ 'scan location'
-    """
-    step = _norm_text(step_line)
-    # define light synonyms
-    SYNS = {
-        "scan": {"scan", "prompt", "display", "show"},
-        "confirm": {"confirm", "verify", "check"},
-        "item": {"item", "sku", "product"},
-        "qty": {"qty", "quantity", "count"},
-        "place": {"place", "put", "stow"},
-        "complete": {"complete", "finish", "done"},
-        "staging": {"staging", "stage", "dock", "door"},
-        "location": {"location", "loc"},
-        "pallet": {"pallet", "container"},
-    }
-
-    hits = 0
-    # count matches when any synonym family term appears in the step line
-    for qt in q_tokens:
-        for fam, words in SYNS.items():
-            if qt == fam or qt in words:
-                if any(w in step for w in words):
-                    hits += 1
-    # simple phrase anchors boost (common picking anchors)
-    PHRASES = ("scan location", "confirm item", "pick quantity", "place picked", "move pallet", "staging area")
-    for ph in PHRASES:
-        if ph in step:
-            hits += 1
-    return hits
-
-def _format_steps_as_numbered(steps: list) -> str:
-    """Render a small list of steps with circled numbers for visual continuity."""
-    circled = {
-        1: "\u2460", 2: "\u2461", 3: "\u2462", 4: "\u2463", 5: "\u2464",
-        6: "\u2465", 7: "\u2466", 8: "\u2467", 9: "\u2468", 10: "\u2469",
-        11: "\u246a", 12: "\u246b", 13: "\u246c", 14: "\u246d", 15: "\u246e",
-        16: "\u246f", 17: "\u2470", 18: "\u2471", 19: "\u2472", 20: "\u2473"
-    }
-    out = []
-    for i, s in enumerate(steps, start=1):
-        out.append(f"{circled.get(i, str(i))} {s}")
-    return "\n".join(out)
-
-
-# --- NEW: sentence-level action filter for mixed paragraphs ---
-def _filter_sentences_by_actions(numbered_text: str,
-                                 wanted: set[str],
-                                 exclude: set[str]) -> str:
-    """
-    Works on already-numbered text. Splits each line into sentences and
-    keeps only sentences that match wanted actions; drops sentences matching exclude actions.
-    Falls back gracefully if no wanted match is found.
-    """
-    ACTION_SYNONYMS = {
-        "create": ("create", "creation", "add", "new", "generate", "setup", "set up", "register"),
-        "update": ("update", "modify", "change", "edit", "amend"),
-        "delete": ("delete", "remove", "cancel", "void"),
-        "navigate": ("navigate", "go to", "open"),
-    }
-
-    def _has_any(text: str, keys: set[str]) -> bool:
-        low = (text or "").lower()
-        for k in keys:
-            for syn in ACTION_SYNONYMS.get(k, (k,)):
-                if syn in low:
-                    return True
-        return False
-
-    def _split_sentences(block: str) -> list:
-        # robust split on ., !, ? followed by space
-        import re
-        parts = [s.strip() for s in re.split(r"(?<=[.!?])\s+", block or "") if s.strip()]
-        return parts if parts else ([block.strip()] if block.strip() else [])
-
-    out_lines = []
-    for ln in (numbered_text or "").splitlines():
-        sent_keep = []
-        sentences = _split_sentences(ln)
-        for s in sentences:
-            if exclude and _has_any(s, exclude):
-                continue
-            if wanted:
-                if _has_any(s, wanted):
-                    sent_keep.append(s)
-            else:
-                # no explicit wanted → keep unless excluded
-                sent_keep.append(s)
-
-        # If nothing matched wanted but line mentions wanted elsewhere, keep the whole line
-        if wanted and not sent_keep:
-            if _has_any(ln, wanted) and not _has_any(ln, exclude):
-                sent_keep = sentences
-
-        if sent_keep:
-            out_lines.append(" ".join(sent_keep))
-
-    return "\n".join(out_lines).strip() or (numbered_text or "").strip()
+    next_steps = steps[start:end]
+    return [ln for ln in _dedupe_lines("\n".join(next_steps)).splitlines() if ln.strip()]
 
+# ---------------- Context filtering (neutral/errors rendering) ----------------
 def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str, Any]]:
     STRICT_OVERLAP = 3
     MAX_SENTENCES_STRICT = 4
@@ -615,20 +371,19 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
         t = re.sub(r"\s+", " ", t).strip()
         return t
 
-    def _split_sentences(ctx: str) -> List[str]:
+    def _split_sents(ctx: str) -> List[str]:
         raw_sents = re.split(r"(?<=[.!?])\s+", ctx or "")
         return [s.strip() for s in raw_sents if s and len(s.strip()) > 2]
 
     ctx = (context or "").strip()
     if not ctx or not query:
         return ctx, {'mode': 'concise', 'matched_count': 0, 'all_sentences': 0}
-
     q_norm = _norm(query)
     q_terms = [t for t in q_norm.split() if len(t) > 2]
     if not q_terms:
         return ctx, {'mode': 'concise', 'matched_count': 0, 'all_sentences': 0}
 
-    sentences = _split_sentences(ctx)
+    sentences = _split_sents(ctx)
     matched_exact, matched_any = [], []
     for s in sentences:
         s_norm = _norm(s)
@@ -641,14 +396,18 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
 
     if matched_exact:
         kept = matched_exact[:MAX_SENTENCES_STRICT]
-        return "\n".join(kept).strip(), {'mode': 'exact', 'matched_count': len(kept), 'all_sentences': len(sentences)}
+        return _dedupe_lines("\n".join(kept).strip()), {
+            'mode': 'exact', 'matched_count': len(kept), 'all_sentences': len(sentences)
+        }
     if matched_any:
         kept = matched_any[:MAX_SENTENCES_CONCISE]
-        return "\n".join(kept).strip(), {'mode': 'concise', 'matched_count': len(kept), 'all_sentences': len(sentences)}
-
+        return _dedupe_lines("\n".join(kept).strip()), {
+            'mode': 'concise', 'matched_count': len(kept), 'all_sentences': len(sentences)
+        }
     kept = sentences[:MAX_SENTENCES_CONCISE]
-    return "\n".join(kept).strip(), {'mode': 'concise', 'matched_count': 0, 'all_sentences': len(sentences)}
-
+    return _dedupe_lines("\n".join(kept).strip()), {
+        'mode': 'concise', 'matched_count': 0, 'all_sentences': len(sentences)
+    }
 
 def _extract_errors_only(text: str, max_lines: int = 12) -> str:
     kept: List[str] = []
@@ -659,7 +418,6 @@ def _extract_errors_only(text: str, max_lines: int = 12) -> str:
             break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
-
 def _filter_permission_lines(text: str, max_lines: int = 6) -> str:
     PERM_SYNONYMS = (
         "permission", "permissions", "access", "authorization", "authorisation",
@@ -674,21 +432,18 @@ def _filter_permission_lines(text: str, max_lines: int = 6) -> str:
             break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
-
 def _extract_escalation_line(text: str) -> Optional[str]:
     if not text:
         return None
     lines = _normalize_lines(text)
     if not lines:
         return None
-
     start_idx = None
     for i, ln in enumerate(lines):
         low = ln.lower()
         if "escalation" in low or "escalation path" in low or "escalate" in low:
             start_idx = i
             break
-
     block: List[str] = []
     if start_idx is not None:
         for j in range(start_idx, min(len(lines), start_idx + 6)):
@@ -697,29 +452,24 @@ def _extract_escalation_line(text: str) -> Optional[str]:
             block.append(lines[j].strip())
     else:
         block = [ln.strip() for ln in lines if ("->" in ln or "→" in ln)]
-
     if not block:
         return None
-
     text_block = " ".join(block)
     m = re.search(r"escalation[^:]*:\s*(.+)", text_block, flags=re.IGNORECASE)
     path = m.group(1).strip() if m else None
-
     if not path:
         arrow_lines = [ln for ln in block if ("->" in ln or "→" in ln)]
         if arrow_lines:
             path = arrow_lines[0]
     if not path:
-        m2 = re.search(r"(operator.*?administrator|operator.*)", text_block, flags=re.IGNORECASE)
+        m2 = re.search(r"(operator.*?administrator.*operator.*)", text_block, flags=re.IGNORECASE)
         path = m2.group(1).strip() if m2 else None
     if not path:
         return None
-
     path = path.replace("->", "→").strip()
     path = re.sub(r"^(?i:escalation\s*path)\s*:\s*", "", path).strip()
     return f"If you want to escalate the issue, follow: {path}"
 
-
 def _detect_language_hint(msg: str) -> Optional[str]:
     if re.search(r"[\u0B80-\u0BFF]", msg or ""):  # Tamil
         return "Tamil"
@@ -727,13 +477,9 @@ def _detect_language_hint(msg: str) -> Optional[str]:
         return "Hindi"
     return None
 
-
 def _build_clarifying_message() -> str:
-    return (
-        "It seems the issue isn’t resolved yet. Would you like to share a few details so I can check further, "
-        "or should I raise a ServiceNow ticket for you?"
-    )
-
+    return ("It seems the issue isn’t resolved yet. Would you like to share a few details so I can check further, "
+            "or should I raise a ServiceNow ticket for you?")
 
 def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[str, str]:
     issue = (issue_text or "").strip()
@@ -746,7 +492,6 @@ def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[s
     ).strip()
     return short_desc, long_desc
 
-
 def _is_incident_intent(msg_norm: str) -> bool:
     intent_phrases = [
         "create ticket", "create a ticket", "raise ticket", "raise a ticket", "open ticket", "open a ticket",
@@ -756,7 +501,6 @@ def _is_incident_intent(msg_norm: str) -> bool:
     ]
     return any(p in msg_norm for p in intent_phrases)
 
-
 def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
     status_keywords = ["status", "ticket status", "incident status", "check status", "check ticket status", "check incident status"]
     base_has_status = any(k in msg_norm for k in status_keywords)
@@ -764,10 +508,8 @@ def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
         any(w in msg_norm for w in ("ticket", "incident", "servicenow", "snow"))
         or bool(re.search(r"\binc\d{5,}\b", msg_norm, flags=re.IGNORECASE))
     )
-    # Disambiguation: if it's a domain status query and not clearly ticket/incident, do NOT route to ticket-status.
     if (not base_has_status) or (base_has_status and not has_ticket_marker and _is_domain_status_context(msg_norm)):
         return {}
-
     patterns = [
         r"(?:incident\s*id|incidentid|ticket\s*number|number)\s*[:=]?\s*(inc\d+)",
         r"(inc\d+)"
@@ -780,7 +522,6 @@ def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
                 return {"number": val.upper() if val.lower().startswith("inc") else val}
     return {"number": None, "ask_number": True}
 
-
 def _is_resolution_ack_heuristic(msg_norm: str) -> bool:
     phrases = [
         "it is resolved", "resolved", "issue resolved", "problem resolved",
@@ -789,7 +530,6 @@ def _is_resolution_ack_heuristic(msg_norm: str) -> bool:
     ]
     return any(p in msg_norm for p in phrases)
 
-
 def _has_negation_resolved(msg_norm: str) -> bool:
     neg_phrases = [
         "not resolved", "issue not resolved", "still not working", "not working",
@@ -797,15 +537,9 @@ def _has_negation_resolved(msg_norm: str) -> bool:
     ]
     return any(p in msg_norm for p in neg_phrases)
 
-
 def _find_prereq_section_text(best_doc: str) -> str:
-    """Return the prerequisites section text, trying common heading variants."""
     variants = [
-        "Pre-Requisites",
-        "Prerequisites",
-        "Pre Requisites",
-        "Pre-Requirements",
-        "Requirements",
+        "Pre-Requisites", "Prerequisites", "Pre Requisites", "Pre-Requirements", "Requirements",
     ]
     for title in variants:
         txt = get_section_text(best_doc, title)
@@ -813,25 +547,23 @@ def _find_prereq_section_text(best_doc: str) -> str:
             return txt.strip()
     return ""
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # Health
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 @app.get("/")
 async def health_check():
     return {"status": "ok"}
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # Chat
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 @app.post("/chat")
 async def chat_with_ai(input_data: ChatInput):
     assist_followup: Optional[str] = None
     try:
         msg_norm = (input_data.user_message or "").lower().strip()
 
-        # Yes/No handlers
+        # yes/no handlers
         if msg_norm in ("yes", "y", "sure", "ok", "okay"):
             return {
                 "bot_response": "Great! Tell me what you'd like to do next — check another ticket, create an incident, or describe your issue.",
@@ -850,11 +582,10 @@ async def chat_with_ai(input_data: ChatInput):
                 "debug": {"intent": "end_conversation"},
             }
 
-        # Resolution ack (auto incident + mark Resolved)
+        # resolution ack (auto incident + mark Resolved)
         is_llm_resolved = _classify_resolution_llm(input_data.user_message)
         if _has_negation_resolved(msg_norm):
             is_llm_resolved = False
-
         if (not _has_negation_resolved(msg_norm)) and (_is_resolution_ack_heuristic(msg_norm) or is_llm_resolved):
             try:
                 short_desc, long_desc = _build_tracking_descriptions(input_data.last_issue, input_data.user_message)
@@ -906,12 +637,10 @@ async def chat_with_ai(input_data: ChatInput):
                     "debug": {"intent": "resolved_ack", "exception": True},
                 }
 
-        # Incident intent
+        # incident intent
         if _is_incident_intent(msg_norm):
             return {
-                "bot_response": (
-                    "Okay, let's create a ServiceNow incident."
-                ),
+                "bot_response": "Okay, let's create a ServiceNow incident.",
                 "status": (input_data.prev_status or "PARTIAL"),
                 "context_found": False,
                 "ask_resolved": False,
@@ -923,7 +652,7 @@ async def chat_with_ai(input_data: ChatInput):
                 "debug": {"intent": "create_ticket"},
             }
 
-        # Status intent (ticket/incident) — disambiguated
+        # ticket status
         status_intent = _parse_ticket_status_intent(msg_norm)
         if status_intent:
             if status_intent.get("ask_number"):
@@ -947,7 +676,6 @@ async def chat_with_ai(input_data: ChatInput):
                 instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
                 if not instance_url:
                     raise HTTPException(status_code=500, detail="SERVICENOW_INSTANCE_URL missing")
-
                 headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
                 number = status_intent.get("number")
                 url = f"{instance_url}/api/now/table/incident?number={number}"
@@ -955,12 +683,10 @@ async def chat_with_ai(input_data: ChatInput):
                 data = response.json()
                 lst = data.get("result", [])
                 result = (lst or [{}])[0] if response.status_code == 200 else {}
-
                 state_code = builtins.str(result.get("state", "unknown"))
                 state_label = STATE_MAP.get(state_code, state_code)
                 short = result.get("short_description", "")
                 num = result.get("number", number or "unknown")
-
                 return {
                     "bot_response": (
                         f"**Ticket:** {num}\n"
@@ -980,9 +706,7 @@ async def chat_with_ai(input_data: ChatInput):
             except Exception as e:
                 raise HTTPException(status_code=500, detail=safe_str(e))
 
-        # -----------------------------
-        # Hybrid KB search
-        # -----------------------------
+        # ------------------ Hybrid KB search ------------------
         kb_results = hybrid_search_knowledge_base(input_data.user_message, top_k=10, alpha=0.6, beta=0.4)
         documents = kb_results.get("documents", [])
         metadatas = kb_results.get("metadatas", [])
@@ -1006,35 +730,27 @@ async def chat_with_ai(input_data: ChatInput):
 
         selected = items[:max(1, 2)]
         context_raw = "\n\n---\n\n".join([s["text"] for s in selected]) if selected else ""
-
         filtered_text, filt_info = _filter_context_for_query(context_raw, input_data.user_message)
         context = filtered_text
         context_found = bool(context.strip())
 
-        best_distance = (
-            min([d for d in distances if d is not None], default=None) if distances else None
-        )
-        best_combined = (
-            max([c for c in combined if c is not None], default=None) if combined else None
-        )
+        best_distance = (min([d for d in distances if d is not None], default=None) if distances else None)
+        best_combined = (max([c for c in combined if c is not None], default=None) if combined else None)
 
         detected_intent = kb_results.get("user_intent", "neutral")
         best_doc = kb_results.get("best_doc")
         top_meta = (metadatas or [{}])[0] if metadatas else {}
         msg_low = (input_data.user_message or "").lower()
-
         GENERIC_ERROR_TERMS = ("error", "issue", "problem", "not working", "failed", "failure")
         generic_error_signal = any(t in msg_low for t in GENERIC_ERROR_TERMS)
 
-        # Query-based prereq nudge
-        PREREQ_TERMS = (
-            "pre req", "pre-requisite", "pre-requisites", "prerequisite",
-            "prerequisites", "pre requirement", "pre-requirements", "requirements"
-        )
+        # intent nudge for prereqs
+        PREREQ_TERMS = ("pre req", "pre-requisite", "pre-requisites", "prerequisite",
+                        "prerequisites", "pre requirement", "pre-requirements", "requirements")
         if detected_intent == "neutral" and any(t in msg_low for t in PREREQ_TERMS):
             detected_intent = "prereqs"
 
-        # Permissions force
+        # permission queries force 'errors'
         PERM_QUERY_TERMS = [
             "permission", "permissions", "access", "access right", "authorization", "authorisation",
             "role", "role access", "security", "security profile", "privilege",
@@ -1044,23 +760,13 @@ async def chat_with_ai(input_data: ChatInput):
         if is_perm_query:
             detected_intent = "errors"
 
-        # Heading-aware prereq nudge
+        # heading-aware prereq nudge
         sec_title = ((top_meta or {}).get("section") or "").strip().lower()
-        PREREQ_HEADINGS = (
-            "pre-requisites", "prerequisites", "pre requisites",
-            "pre-requirements", "requirements"
-        )
+        PREREQ_HEADINGS = ("pre-requisites", "prerequisites", "pre requisites", "pre-requirements", "requirements")
         if detected_intent == "neutral" and any(h in sec_title for h in PREREQ_HEADINGS):
             detected_intent = "prereqs"
 
-        # ---- FORCE STEPS for "what's next" / "next step" queries ----
-        try:
-            if _detect_next_intent(input_data.user_message):
-                detected_intent = "steps"
-        except Exception:
-            pass
-
-        # Gating
+        # gating
         def _contains_any(s: str, keywords: tuple) -> bool:
             low = (s or "").lower()
             return any(k in low for k in keywords)
@@ -1078,19 +784,16 @@ async def chat_with_ai(input_data: ChatInput):
             "error", "issue", "fail", "failed", "not working", "locked", "mismatch",
             "access", "permission", "status"
         )
-
         matched_count = int(filt_info.get("matched_count") or 0)
         filter_mode = (filt_info.get("mode") or "").lower()
         has_any_action_or_error = _contains_any(msg_low, ACTION_OR_ERROR_TERMS)
         mentions_domain = _contains_any(msg_low, DOMAIN_TERMS)
-
         short_query = len((input_data.user_message or "").split()) <= 4
         gate_combined_ok = 0.60 if short_query else 0.55
         combined_ok = (best_combined is not None and best_combined >= gate_combined_ok)
         weak_domain_only = (mentions_domain and not has_any_action_or_error)
         low_context_hit = (matched_count < 2 and filter_mode in ("concise", "exact"))
-
-        strong_steps_bypass = True  # next-step override already set steps; allow
+        strong_steps_bypass = True
         strong_error_signal = len(_detect_error_families(msg_low)) > 0
 
         if (weak_domain_only or (low_context_hit and not combined_ok)) \
@@ -1119,7 +822,7 @@ async def chat_with_ai(input_data: ChatInput):
                 },
             }
 
-        # Build SOP context if allowed
+        # ---------- Build SOP context ----------
         escalation_line: Optional[str] = None
         full_errors: Optional[str] = None
         next_step_applied = False
@@ -1127,25 +830,26 @@ async def chat_with_ai(input_data: ChatInput):
         context_preformatted = False
 
         if best_doc and detected_intent == "steps":
+            # prefer exact section of the top hit; fallback to all steps
             sec = (top_meta or {}).get("section")
             if sec:
-        # Prefer the exact section of the top hit
-              full_steps = get_section_text(best_doc, sec)
+                full_steps = get_section_text(best_doc, sec)
             else:
-        # Fallback to all steps (rare)
-              full_steps = get_best_steps_section_text(best_doc)
-            
+                full_steps = get_best_steps_section_text(best_doc)
+
             if full_steps:
                 numbered_full = _ensure_numbering(full_steps)
+
+                # action filtering (create/update/delete) – only when user clearly asks
                 raw_actions = set((kb_results.get("actions") or []))
-                msg_low = (input_data.user_message or "").lower()
-# Fallbacks if extractor missed it
-                if not raw_actions and ("creation" in msg_low or "create" in msg_low or "set up" in msg_low or "setup" in msg_low):
+                msg_low2 = (input_data.user_message or "").lower()
+                if not raw_actions and ("creation" in msg_low2 or "create" in msg_low2 or "set up" in msg_low2 or "setup" in msg_low2):
                     raw_actions = {"create"}
-                elif not raw_actions and ("update" in msg_low or "modify" in msg_low or "edit" in msg_low or "change" in msg_low):
+                elif not raw_actions and ("update" in msg_low2 or "modify" in msg_low2 or "edit" in msg_low2 or "change" in msg_low2):
                     raw_actions = {"update"}
-                elif not raw_actions and ("delete" in msg_low or "remove" in msg_low or "cancel" in msg_low or "void" in msg_low):
+                elif not raw_actions and ("delete" in msg_low2 or "remove" in msg_low2 or "cancel" in msg_low2 or "void" in msg_low2):
                     raw_actions = {"delete"}
+
                 wanted, exclude = set(), set()
                 if "create" in raw_actions and not ({"update", "delete"} & raw_actions):
                     wanted, exclude = {"create"}, {"update", "delete"}
@@ -1153,19 +857,13 @@ async def chat_with_ai(input_data: ChatInput):
                     wanted, exclude = {"update"}, {"create", "delete"}
                 elif "delete" in raw_actions and not ({"create", "update"} & raw_actions):
                     wanted, exclude = {"delete"}, {"create", "update"}
+
                 if wanted or exclude:
-            # Sentence-level filtering for mixed paragraphs
-                   numbered_full = _filter_sentences_by_actions(
-                      numbered_full, wanted=wanted, exclude=exclude
-            )
-
-                     
-                next_only = _resolve_next_steps(
-                    input_data.user_message,
-                    numbered_full,
-                    max_next=6,
-                    min_score=0.35
-                )
+                    numbered_full = _filter_numbered_steps_by_actions(numbered_full, wanted=wanted, exclude=exclude)
+
+                # --- NEW: keyword-free anchor-based next-step resolver ---
+                next_only = _anchor_next_steps(input_data.user_message, numbered_full, max_next=6)
+
                 if next_only is not None:
                     if len(next_only) == 0:
                         context = "You are at the final step of this SOP. No further steps."
@@ -1174,12 +872,13 @@ async def chat_with_ai(input_data: ChatInput):
                         context_preformatted = True
                     else:
                         context = _format_steps_as_numbered(next_only)
+                        context = _dedupe_lines(context)
                         next_step_applied = True
                         next_step_info = {"count": len(next_only)}
                         context_preformatted = True
                 else:
-                    context = full_steps
-                    context_preformatted = False
+                    context = numbered_full
+                    context_preformatted = True
 
                 # clear filter info for debug clarity
                 filt_info = {'mode': None, 'matched_count': None, 'all_sentences': None}
@@ -1202,10 +901,10 @@ async def chat_with_ai(input_data: ChatInput):
                             if re.match(r"^\s*[\-\*\u2022]\s*", ln) or (":" in ln)
                         ]
                         context = "\n".join(error_bullets[:8]).strip()
-                        assist_followup = (
-                            "Please tell me which error above matches your screen (paste the exact text), "
-                            "or share a screenshot. I can guide you further or raise a ServiceNow ticket."
-                        )
+                assist_followup = (
+                    "Please tell me which error above matches your screen (paste the exact text), "
+                    "or share a screenshot. I can guide you further or raise a ServiceNow ticket."
+                )
                 escalation_line = _extract_escalation_line(full_errors)
 
         elif best_doc and detected_intent == "prereqs":
@@ -1213,16 +912,14 @@ async def chat_with_ai(input_data: ChatInput):
             if full_prereqs:
                 context = full_prereqs.strip()
                 context_found = True
-
         else:
-            # Neutral or other intents: use filtered context
-            context = filtered_text
+            # neutral or other intents: keep filtered context (already set as 'context')
+            pass
 
-        # Language hint & paraphrase (for errors only)
+        # language hint & paraphrase (errors only)
         language_hint = _detect_language_hint(input_data.user_message)
         lang_line = f"Respond in {language_hint}." if language_hint else "Respond in a clear, polite tone."
         use_gemini = (detected_intent == "errors")
-
         enhanced_prompt = f"""You are a helpful support assistant. Rewrite the provided context ONLY into clear, user-friendly guidance.
 - Do not add any information that is not present in the context.
 - If the content is an error/access/permission note, paraphrase it into a helpful sentence users can understand.
@@ -1233,7 +930,6 @@ async def chat_with_ai(input_data: ChatInput):
 {input_data.user_message}
 ### Output
 Return ONLY the rewritten guidance."""
-
         headers = {"Content-Type": "application/json"}
         payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]}
         bot_text = ""
@@ -1254,7 +950,7 @@ Return ONLY the rewritten guidance."""
             except Exception:
                 bot_text, http_code = "", 0
 
-        # Deterministic local formatting
+        # deterministic local formatting
         if detected_intent == "steps":
             if context_preformatted:
                 bot_text = context
@@ -1268,7 +964,7 @@ Return ONLY the rewritten guidance."""
         else:
             bot_text = context
 
-        # Append escalation if explicitly requested even in steps mode
+        # explicit escalation add in steps if user asked
         needs_escalation = (" escalate" in msg_norm) or ("escalation" in msg_norm)
         if needs_escalation and best_doc:
             esc_text = get_escalation_text(best_doc)
@@ -1278,7 +974,7 @@ Return ONLY the rewritten guidance."""
             if line:
                 bot_text = (bot_text or "").rstrip() + "\n\n" + line
 
-        # Non-empty guarantee
+        # non-empty guarantee
         if not (bot_text or "").strip():
             if context.strip():
                 bot_text = context.strip()
@@ -1291,7 +987,6 @@ Return ONLY the rewritten guidance."""
         short_query = len((input_data.user_message or "").split()) <= 4
         gate_combined_ok = 0.60 if short_query else 0.55
         status = "OK" if (best_combined is not None and best_combined >= gate_combined_ok) else "PARTIAL"
-
         lower = (bot_text or "").lower()
         if ("partial" in lower) or ("may be partial" in lower) or ("closest" in lower) or ("may not fully" in lower):
             status = "PARTIAL"
@@ -1326,10 +1021,9 @@ Return ONLY the rewritten guidance."""
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # Ticket description generation
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 @app.post("/generate_ticket_desc")
 async def generate_ticket_desc_ep(input_data: TicketDescInput):
     try:
@@ -1349,16 +1043,13 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
             data = resp.json()
         except Exception:
             return {"ShortDescription": "", "DetailedDescription": "", "error": "Gemini returned non-JSON"}
-
         try:
             text = data.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "").strip()
         except Exception:
             return {"ShortDescription": "", "DetailedDescription": "", "error": "Gemini parsing failed"}
-
         if text.startswith("```"):
             lines = [ln for ln in text.splitlines() if not ln.strip().startswith("```")]
             text = "\n".join(lines).strip()
-
         try:
             ticket_json = json.loads(text)
             return {
@@ -1367,14 +1058,12 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
             }
         except Exception:
             return {"ShortDescription": "", "DetailedDescription": "", "error": "Invalid JSON returned"}
-
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # Incident status
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 @app.post("/incident_status")
 async def incident_status(input_data: TicketStatusInput):
     try:
@@ -1382,9 +1071,7 @@ async def incident_status(input_data: TicketStatusInput):
         instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
         if not instance_url:
             raise HTTPException(status_code=500, detail="SERVICENOW_INSTANCE_URL missing")
-
         headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
-
         if input_data.sys_id:
             url = f"{instance_url}/api/now/table/incident/{input_data.sys_id}"
             response = requests.get(url, headers=headers, verify=VERIFY_SSL, timeout=25)
@@ -1398,12 +1085,10 @@ async def incident_status(input_data: TicketStatusInput):
             result = (lst or [{}])[0] if response.status_code == 200 else {}
         else:
             raise HTTPException(status_code=400, detail="Provide IncidentID (number) or sys_id")
-
         state_code = builtins.str(result.get("state", "unknown"))
         state_label = STATE_MAP.get(state_code, state_code)
         short = result.get("short_description", "")
         number = result.get("number", input_data.number or "unknown")
-
         return {
             "bot_response": (
                 f"**Ticket:** {number} \n"
@@ -1415,14 +1100,12 @@ async def incident_status(input_data: TicketStatusInput):
             "persist": True,
             "debug": "Incident status fetched",
         }
-
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
-
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 # Incident creation
-# ------------------------------------------------------------------------------
+# ---------------------------------------------------------------------
 def _classify_resolution_llm(user_message: str) -> bool:
     if not GEMINI_API_KEY:
         return False
@@ -1444,7 +1127,6 @@ Message: {user_message}"""
     except Exception:
         return False
 
-
 def _set_incident_resolved(sys_id: str) -> bool:
     try:
         token = get_valid_token()
@@ -1452,21 +1134,18 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if not instance_url:
             print("[SN PATCH resolve] missing SERVICENOW_INSTANCE_URL")
             return False
-
         headers = {
             "Authorization": f"Bearer {token}",
             "Accept": "application/json",
             "Content-Type": "application/json",
         }
         url = f"{instance_url}/api/now/table/incident/{sys_id}"
-
         close_code_val = os.getenv("SERVICENOW_CLOSE_CODE", "Solution provided")
         close_notes_val = os.getenv("SERVICENOW_RESOLUTION_NOTES", "Issue resolved, user confirmed")
         caller_sysid = os.getenv("SERVICENOW_CALLER_SYSID")
         resolved_by_sysid = os.getenv("SERVICENOW_RESOLVED_BY_SYSID")
         assign_group = os.getenv("SERVICENOW_ASSIGNMENT_GROUP_SYSID")
         require_progress = os.getenv("SERVICENOW_REQUIRE_IN_PROGRESS_FIRST", "false").lower() in ("1", "true", "yes")
-
         if require_progress:
             try:
                 resp1 = requests.patch(url, headers=headers, json={"state": "2"}, verify=VERIFY_SSL, timeout=25)
@@ -1511,7 +1190,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         notes_field = os.getenv("SERVICENOW_RESOLUTION_NOTES_FIELD", "close_notes")
         payload_C = clean({
             "state": "6",
-            code_field: close_notes_val,  # adjust if custom fields
+            code_field: close_notes_val,  # adjust if custom fields are mapped differently
             notes_field: close_notes_val,
             "caller_id": caller_sysid,
             "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
@@ -1523,13 +1202,11 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if respC.status_code in (200, 204):
             return True
         print(f"[SN PATCH resolve C] status={respC.status_code} body={respC.text[:500]}")
-
         return False
     except Exception as e:
         print(f"[SN PATCH resolve] exception={safe_str(e)}")
         return False
 
-
 @app.post("/incident")
 async def raise_incident(input_data: IncidentInput):
     try: