Update main.py

main.py

@@ -1,4 +1,6 @@
 
+# main_hugging_phase_recent.py
+
 import os
 import json
 import re
@@ -27,15 +29,18 @@ from services.generate_ticket import get_valid_token, create_incident
 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")
 
+
 def safe_str(e: Any) -> str:
     try:
         return builtins.str(e)
     except Exception:
         return "<error stringify failed>"
 
+
 load_dotenv()
 os.environ["POSTHOG_DISABLED"] = "true"
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     try:
@@ -49,6 +54,7 @@ async def lifespan(app: FastAPI):
         print(f"[KB] ingestion failed: {safe_str(e)}")
     yield
 
+
 app = FastAPI(lifespan=lifespan)
 app.include_router(login_router)
 
@@ -67,18 +73,22 @@ class ChatInput(BaseModel):
     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",
@@ -134,10 +144,10 @@ ERROR_FAMILY_SYNS = {
     ),
 }
 
+
 def _detect_error_families(msg: str) -> list:
     """Return matching error family names found in the message (generic across SOPs)."""
     low = (msg or "").lower()
-    import re
     low_norm = re.sub(r"[^\w\s]", " ", low)
     low_norm = re.sub(r"\s+", " ", low_norm).strip()
     fams = []
@@ -146,11 +156,13 @@ 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:
@@ -158,59 +170,69 @@ def _normalize_lines(text: str) -> List[str]:
     except Exception:
         return [raw.strip()] if raw.strip() else []
 
+
 def _ensure_numbering(text: str) -> str:
-    import re
+    """
+    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 "")
-    def strip_prefix_any(s: str) -> str:
-        return re.sub(
-            r"^\s*(?:[\u2060\u200B]*"
-            r"(?:\d+\s*[.)])"
-            r"|(?:step\s*\d+:?)"
-            r"|(?:[\-\*\u2022])"
-            r"|(?:[\u2460-\u2473]))\s*",
-            "", (s or "").strip(), flags=re.IGNORECASE
-        )
     lines = [ln.strip() for ln in (text or "").splitlines() if ln and ln.strip()]
     if not lines:
         return text or ""
-    merged: List[str] = []
-    i = 0
-    while i < len(lines):
-        ln = lines[i]
-        if re.fullmatch(r"\d+[.)]?|[\u2460-\u2473]", ln) and (i + 1) < len(lines):
-            merged.append(lines[i + 1].strip())
-            i += 2
-        else:
-            merged.append(ln)
-            i += 1
-    para = " ".join(merged).strip()
+
+    # Collapse lines into a block and then split on common step markers
+    para = " ".join(lines).strip()
     if not para:
         return ""
-    para_clean = re.sub(r"(?:\b\d+[.)]\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)
+
+    # Create hard breaks at typical step boundaries
+    para_clean = re.sub(r"(?:\b\d+[.)]\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:
     segments = [seg.strip() for seg in para_clean.split("\n\n\n") if seg.strip()]
+
+    # Fallback splitting if we didn't detect separators
     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+|\s+;\s+", para) if seg.strip()]
-    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: List[str] = []
-    for idx, seg in enumerate(segments, start=1):
+
+    # Strip any step prefixes
+    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
+        )
+
+    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)
 
-# --- Next-step helpers (generic; SOP-agnostic) ---
 
+# --- Next-step helpers (generic; SOP-agnostic) ---
 def _norm_text(s: str) -> str:
-    import re
     s = (s or "").lower()
     s = re.sub(r"[^\w\s]", " ", s)
     s = re.sub(r"\s+", " ", s).strip()
     return s
 
+
 def _split_sop_into_steps(numbered_text: str) -> list:
     """
     Split a numbered/bulleted SOP block (already passed through _ensure_numbering)
@@ -220,13 +242,12 @@ def _split_sop_into_steps(numbered_text: str) -> list:
     lines = [ln.strip() for ln in (numbered_text or "").splitlines() if ln.strip()]
     steps = []
     for ln in lines:
-        # Strip circled/number/bullet marker
-        cleaned = ln
-        cleaned = re.sub(r"^\s*(?:[\u2460-\u2473]|\d+[.)]|[-*•])\s*", "", cleaned)
+        cleaned = re.sub(r"^\s*(?:[\u2460-\u2473]|\d+[.)]|[-*•])\s*", "", ln)
         if cleaned:
             steps.append(cleaned)
     return steps
 
+
 def _soft_match_score(a: str, b: str) -> float:
     # Simple Jaccard-like score on tokens for fuzzy matching
     ta = set(_norm_text(a).split())
@@ -237,15 +258,16 @@ def _soft_match_score(a: str, b: str) -> float:
     union = len(ta | tb)
     return inter / union if union else 0.0
 
+
 def _detect_next_intent(user_query: str) -> bool:
     q = _norm_text(user_query)
-    # Conservative rules to avoid false triggers
     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 = 6, min_score: float = 0.35):
     """
     If 'what's next' intent is detected and we can reliably match the user's
@@ -262,7 +284,6 @@ def _resolve_next_steps(user_query: str, numbered_text: str, max_next: int = 6,
     q = user_query or ""
     best_idx, best_score = -1, -1.0
     for idx, step in enumerate(steps):
-        # Exact substring match gets max score; else use soft match
         score = 1.0 if _norm_text(step) in _norm_text(q) else _soft_match_score(q, step)
         if score > best_score:
             best_score, best_idx = score, idx
@@ -277,17 +298,21 @@ def _resolve_next_steps(user_query: str, numbered_text: str, max_next: int = 6,
     end = min(start + max_next, len(steps))
     return steps[start:end]
 
+
 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"}
+    """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)
 
+
 def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 1) -> str:
     """
     Pick the most relevant 'Common Errors & Resolution' bullet(s) for the user's message.
@@ -300,10 +325,6 @@ def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 1) -> s
 
     Returns exactly `max_lines` best-scoring lines (defaults to 1).
     """
-
-    import re
-    from typing import List, Tuple
-
     def _norm(s: str) -> str:
         s = (s or "").lower()
         s = re.sub(r"[^\w\s]", " ", s)
@@ -311,7 +332,7 @@ def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 1) -> s
         return s
 
     def _ngrams(tokens: List[str], n: int) -> List[str]:
-        return [" ".join(tokens[i:i+n]) for i in range(len(tokens) - n + 1)]
+        return [" ".join(tokens[i:i + n]) for i in range(len(tokens) - n + 1)]
 
     def _families_for(s: str) -> set:
         low = _norm(s)
@@ -336,7 +357,7 @@ def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 1) -> s
         ln_norm = _norm(ln)
         ln_fams = _families_for(ln)
 
-        fam_overlap = len(q_fams & ln_fams)         # strong signal
+        fam_overlap = len(q_fams & ln_fams)
         anchored = 0.0
         first2 = " ".join(q_tokens[:2]) if len(q_tokens) >= 2 else ""
         first3 = " ".join(q_tokens[:3]) if len(q_tokens) >= 3 else ""
@@ -348,7 +369,6 @@ def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 1) -> s
         token_overlap = sum(1 for t in q_tokens if t and t in ln_norm)
         exact_phrase = 1.0 if (q and q in ln_norm) else 0.0
 
-        # Composite score (tuned generically)
         score = (
             1.70 * fam_overlap +
             1.00 * anchored +
@@ -358,7 +378,7 @@ def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 1) -> s
             0.30 * token_overlap
         )
 
-        if re.match(r"^\s*[\-\*\u2022]\s*", ln):  # bullet
+        if re.match(r"^\s*[-*\u2022]\s*", ln):  # bullet
             score += 0.10
         heading = ln_norm.split(":")[0].strip()
         if heading and (heading in q or (first2 and first2 in heading)):
@@ -368,15 +388,14 @@ def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 1) -> s
 
     scored.sort(key=lambda x: x[0], reverse=True)
     top = [ln for s, ln in scored[:max_lines] if s > 0.0]
-
     if not top:
         top = lines[:max_lines]
-
     return "\n".join(top).strip()
 
+
 def _friendly_permission_reply(raw: str) -> str:
     line = (raw or "").strip()
-    line = re.sub(r"^\s*[\-\*\u2022]\s*", "", line)
+    line = re.sub(r"^\s*[-*\u2022]\s*", "", line)
     if not line:
         return "It looks like you may not have access for this action. Please verify your WMS role/permission with your supervisor or IT."
     if "verify role access" in line.lower():
@@ -385,6 +404,7 @@ def _friendly_permission_reply(raw: str) -> str:
         return f"It seems to be an access issue: {line}. Please check your role mapping or request access."
     return line
 
+
 def _detect_language_hint(msg: str) -> Optional[str]:
     if re.search(r"[\u0B80-\u0BFF]", msg or ""):  # Tamil
         return "Tamil"
@@ -392,9 +412,13 @@ 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()
@@ -407,6 +431,7 @@ 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",
@@ -416,6 +441,7 @@ 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)
@@ -438,6 +464,7 @@ 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",
@@ -446,6 +473,7 @@ 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",
@@ -453,8 +481,8 @@ def _has_negation_resolved(msg_norm: str) -> bool:
     ]
     return any(p in msg_norm for p in neg_phrases)
 
+
 def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str, Any]]:
-    import re
     STRICT_OVERLAP = 3
     MAX_SENTENCES_STRICT = 4
     MAX_SENTENCES_CONCISE = 3
@@ -466,7 +494,7 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
         return t
 
     def _split_sentences(ctx: str) -> List[str]:
-        raw_sents = re.split(r"(?<=[.!?])\s+|\n+|\-\s*|\*\s*", ctx or "")
+        raw_sents = re.split(r"(?<=[.!?])\s+|\n+|-\s*|\*\s*", ctx or "")
         return [s.strip() for s in raw_sents if s and len(s.strip()) > 2]
 
     ctx = (context or "").strip()
@@ -495,23 +523,22 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
     kept = sentences[:MAX_SENTENCES_CONCISE]
     return "\n".join(kept).strip(), {'mode': 'concise', 'matched_count': 0, 'all_sentences': len(sentences)}
 
+
 def _extract_errors_only(text: str, max_lines: int = 12) -> str:
     """
     Collect error bullets/heading-style lines from the SOP errors section.
     Generic: keeps bullet points (•, -, *), and lines that look like "Heading: details".
     This ensures items like 'ASN not found', 'Trailer status locked', etc., are preserved.
     """
-    import re
     kept: List[str] = []
     for ln in _normalize_lines(text):
-        # bullet (•, -, *) OR a heading-like line that contains a colon (e.g., "ASN not found: ...")
-        if re.match(r"^\s*[\-\*\u2022]\s*", ln) or (":" in ln):
+        if re.match(r"^\s*[-*\u2022]\s*", ln) or (":" in ln):
             kept.append(ln)
             if len(kept) >= max_lines:
                 break
-    # Fallback: if nothing matched, return original text
     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",
@@ -526,6 +553,7 @@ 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
@@ -564,6 +592,7 @@ def _extract_escalation_line(text: str) -> Optional[str]:
     path = re.sub(r"^(?i:escalation\s*path)\s*:\s*", "", path).strip()
     return f"If you want to escalate the issue, follow: {path}"
 
+
 def _classify_resolution_llm(user_message: str) -> bool:
     if not GEMINI_API_KEY:
         return False
@@ -585,6 +614,7 @@ Message: {user_message}"""
     except Exception:
         return False
 
+
 def _set_incident_resolved(sys_id: str) -> bool:
     try:
         token = get_valid_token()
@@ -610,8 +640,10 @@ def _set_incident_resolved(sys_id: str) -> bool:
                 print(f"[SN PATCH progress] status={resp1.status_code} body={resp1.text[:500]}")
             except Exception as e:
                 print(f"[SN PATCH progress] exception={safe_str(e)}")
+
         def clean(d: dict) -> dict:
             return {k: v for k, v in d.items() if v is not None}
+
         payload_A = clean({
             "state": "6",
             "close_code": close_code_val,
@@ -626,6 +658,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if respA.status_code in (200, 204):
             return True
         print(f"[SN PATCH resolve A] status={respA.status_code} body={respA.text[:500]}")
+
         payload_B = clean({
             "state": "Resolved",
             "close_code": close_code_val,
@@ -640,6 +673,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if respB.status_code in (200, 204):
             return True
         print(f"[SN PATCH resolve B] status={respB.status_code} body={respB.text[:500]}")
+
         code_field = os.getenv("SERVICENOW_RESOLUTION_CODE_FIELD", "close_code")
         notes_field = os.getenv("SERVICENOW_RESOLUTION_NOTES_FIELD", "close_notes")
         payload_C = clean({
@@ -661,6 +695,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         print(f"[SN PATCH resolve] exception={safe_str(e)}")
         return False
 
+
 # ------------------------------ Prereq helper ------------------------------
 def _find_prereq_section_text(best_doc: str) -> str:
     """
@@ -680,11 +715,13 @@ 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):
@@ -747,7 +784,7 @@ async def chat_with_ai(input_data: ChatInput):
                         "ask_resolved": False,
                         "suggest_incident": True,
                         "followup": "Shall I create a ticket now?",
-                        "options": [{"type":"yesno","title":"Create ticket now?"}],
+                        "options": [{"type": "yesno", "title": "Create ticket now?"}],
                         "top_hits": [],
                         "sources": [],
                         "debug": {"intent": "resolved_ack", "auto_created": False, "error": err},
@@ -760,7 +797,7 @@ async def chat_with_ai(input_data: ChatInput):
                     "ask_resolved": False,
                     "suggest_incident": True,
                     "followup": "Shall I create a ticket now?",
-                    "options": [{"type":"yesno","title":"Create ticket now?"}],
+                    "options": [{"type": "yesno", "title": "Create ticket now?"}],
                     "top_hits": [],
                     "sources": [],
                     "debug": {"intent": "resolved_ack", "exception": True},
@@ -854,8 +891,10 @@ async def chat_with_ai(input_data: ChatInput):
             score = distances[i] if i < len(distances) else None
             comb = combined[i] if i < len(combined) else None
             m = dict(meta)
-            if score is not None: m["distance"] = score
-            if comb is not None: m["combined"] = comb
+            if score is not None:
+                m["distance"] = score
+            if comb is not None:
+                m["combined"] = comb
             items.append({"text": text, "meta": m})
 
         selected = items[:max(1, 2)]
@@ -961,7 +1000,7 @@ async def chat_with_ai(input_data: ChatInput):
                 "ask_resolved": False,
                 "suggest_incident": True,
                 "followup": "Share more details (module/screen/error), or say 'create ticket'.",
-                "options": [{"type":"yesno","title":"Share details or raise a ticket?"}],
+                "options": [{"type": "yesno", "title": "Share details or raise a ticket?"}],
                 "top_hits": [],
                 "sources": [],
                 "debug": {
@@ -974,7 +1013,6 @@ async def chat_with_ai(input_data: ChatInput):
                     "strong_steps_bypass": strong_steps_bypass,
                     "strong_error_signal": strong_error_signal,
                     "generic_error_signal": generic_error_signal
-
                 },
             }
 
@@ -984,51 +1022,59 @@ async def chat_with_ai(input_data: ChatInput):
 
         escalation_line = None  # SOP escalation candidate
         full_errors = None      # keep for possible escalation extraction
+        next_step_applied = False
+        next_step_info: Dict[str, Any] = {}
 
         if best_doc:
             if detected_intent == "steps":
                 full_steps = get_best_steps_section_text(best_doc)
                 if not full_steps:
                     sec = (top_meta or {}).get("section")
-                    if sec: full_steps = get_section_text(best_doc, sec)
+                    if sec:
+                        full_steps = get_section_text(best_doc, sec)
+
                 if full_steps:
-                    
-                   numbered = _ensure_numbering(full_steps)  # keep your existing formatting
-        # NEW: return only subsequent steps when user asks "what's next"
-                   next_only = _resolve_next_steps(input_data.user_message, numbered, max_next=6, min_score=0.35)
-                   if next_only is not None:
-                      if len(next_only) == 0:
-                         context = "You are at the final step of this SOP. No further steps."
-                      else:
-                          context = _format_steps_as_numbered(next_only)
-                   else:
-                       context=numbered
-                    
+                    # Use numbered form only for matching; keep raw for full output
+                    numbered_full = _ensure_numbering(full_steps)
+                    next_only = _resolve_next_steps(input_data.user_message, numbered_full, max_next=6, min_score=0.35)
+
+                    if next_only is not None:
+                        # "what's next" mode
+                        if len(next_only) == 0:
+                            context = "You are at the final step of this SOP. No further steps."
+                            next_step_applied = True
+                            next_step_info = {"count": 0}
+                            context_preformatted = True
+                        else:
+                            context = _format_steps_as_numbered(next_only)
+                            next_step_applied = True
+                            next_step_info = {"count": len(next_only)}
+                            context_preformatted = True
+                    else:
+                        # Normal mode: return the full SOP section (raw),
+                        # and we'll number it below once.
+                        context = full_steps
+                        context_preformatted = False
+
             elif detected_intent == "errors":
                 full_errors = get_best_errors_section_text(best_doc)
-                #assist_followup = None  # collect a helpful follow-up for generic cases
-
                 if full_errors:
                     ctx_err = _extract_errors_only(full_errors, max_lines=30)
                     if is_perm_query:
                         context = _filter_permission_lines(ctx_err, max_lines=6)
                     else:
                         # Decide specific vs generic:
-                        # - specific: user named a family (NOT_FOUND / LOCKED / MISMATCH / ...)
-                        # - generic: user only said 'issue'/'error' without naming family
                         is_specific_error = len(_detect_error_families(msg_low)) > 0
                         if is_specific_error:
-                           context = _filter_error_lines_by_query(ctx_err, input_data.user_message, max_lines=1)
+                            context = _filter_error_lines_by_query(ctx_err, input_data.user_message, max_lines=1)
                         else:
-                            
                             all_lines: List[str] = _normalize_lines(ctx_err)
-                            error_bullets = [ln for ln in all_lines if re.match(r"^\s*[\-\*\u2022]\s*", ln) or (":" in ln)]
-                            # limit to reasonable count (e.g., 8)
+                            error_bullets = [ln for ln in all_lines 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." )
-
+                                "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 detected_intent == "prereqs":
@@ -1070,12 +1116,19 @@ Return ONLY the rewritten guidance."""
 
         # Deterministic local formatting
         if detected_intent == "steps":
-            bot_text = _ensure_numbering(context)
+            # If we trimmed to next steps, 'context' is already formatted (or a sentence).
+            # Only number when returning full SOP raw text.
+            if ('context_preformatted' in locals()) and context_preformatted:
+                bot_text = context
+            else:
+                bot_text = _ensure_numbering(context)
+
         elif detected_intent == "errors":
             if not bot_text.strip() or http_code == 429:
                 bot_text = context.strip()
             if escalation_line:
                 bot_text = (bot_text or "").rstrip() + "\n\n" + escalation_line
+
         else:
             bot_text = context
 
@@ -1105,7 +1158,8 @@ Return ONLY the rewritten guidance."""
         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"
-        options = [{"type":"yesno","title":"Share details or raise a ticket?"}] if status == "PARTIAL" else []
+        options = [{"type": "yesno", "title": "Share details or raise a ticket?"}] if status == "PARTIAL" else []
+
         return {
             "bot_response": bot_text,
             "status": status,
@@ -1125,6 +1179,10 @@ Return ONLY the rewritten guidance."""
                 "matched_count": filt_info.get("matched_count"),
                 "user_intent": detected_intent,
                 "best_doc": best_doc,
+                "next_step": {
+                    "applied": next_step_applied,
+                    "info": next_step_info,
+                },
             },
         }
     except HTTPException:
@@ -1132,6 +1190,7 @@ 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):
@@ -1170,6 +1229,7 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
     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):
@@ -1210,6 +1270,7 @@ async def incident_status(input_data: TicketStatusInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
+
 # ------------------------------ Incident ------------------------------
 @app.post("/incident")
 async def raise_incident(input_data: IncidentInput):