Update main.py

main.py

@@ -1,5 +1,5 @@
 
-# main_hugging_phase_recent.py
+# main.py (FastAPI runtime) — CLEAN VERSION
 
 import os
 import json
@@ -8,12 +8,14 @@ import requests
 import builtins
 from typing import Optional, Any, Dict, List, Tuple
 from contextlib import asynccontextmanager
+from datetime import datetime
+
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from dotenv import load_dotenv
-from datetime import datetime
 
+# Import KB services
 from services.kb_creation import (
     collection,
     ingest_documents,
@@ -21,13 +23,26 @@ from services.kb_creation import (
     get_section_text,
     get_best_steps_section_text,
     get_best_errors_section_text,
-    get_escalation_text,  # for escalation heading
+    get_escalation_text,
 )
+
+# ServiceNow helpers
 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")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+GEMINI_URL = (
+    "https://generativelanguage.googleapis.com/v1beta/models/"
+    f"gemini-2.5-flash-lite:generateContent?key={GEMINI_API_KEY}"
+)
+os.environ["POSTHOG_DISABLED"] = "true"
 
 
 def safe_str(e: Any) -> str:
@@ -37,10 +52,9 @@ def safe_str(e: Any) -> str:
         return "<error stringify failed>"
 
 
-load_dotenv()
-os.environ["POSTHOG_DISABLED"] = "true"
-
-
+# ------------------------------------------------------------------------------
+# App / Lifespan
+# ------------------------------------------------------------------------------
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     try:
@@ -58,7 +72,11 @@ async def lifespan(app: FastAPI):
 app = FastAPI(lifespan=lifespan)
 app.include_router(login_router)
 
-origins = ["https://chatbotnova-chatbot-frontend.hf.space"]
+# Allow your HF Space frontend; add localhost for local dev if needed
+origins = [
+    "https://chatbotnova-chatbot-frontend.hf.space",
+    # "http://localhost:5173",  # uncomment for local dev (Vite)
+]
 app.add_middleware(
     CORSMiddleware,
     allow_origins=origins,
@@ -67,7 +85,10 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ------------------------------ Models ------------------------------
+
+# ------------------------------------------------------------------------------
+# Models
+# ------------------------------------------------------------------------------
 class ChatInput(BaseModel):
     user_message: str
     prev_status: Optional[str] = None
@@ -98,16 +119,12 @@ STATE_MAP = {
     "8": "Canceled",
 }
 
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-GEMINI_URL = (
-    f"https://generativelanguage.googleapis.com/v1beta/models/"
-    f"gemini-2.5-flash-lite:generateContent?key={GEMINI_API_KEY}"
-)
 
-# ------------------------------ Helpers ------------------------------
+# ------------------------------------------------------------------------------
+# Generic helpers
+# ------------------------------------------------------------------------------
 NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()  # 'digit' or 'step'
 
-# Domain status terms (generic WMS domain words)
 DOMAIN_STATUS_TERMS = (
     "shipment", "order", "load", "trailer", "wave",
     "inventory", "putaway", "receiving", "appointment",
@@ -115,7 +132,6 @@ DOMAIN_STATUS_TERMS = (
     "asn", "grn", "pick", "picking"
 )
 
-# --- Generic error families (SOP-wide, reusable in gating and line selection) ---
 ERROR_FAMILY_SYNS = {
     "NOT_FOUND": (
         "not found", "missing", "does not exist", "doesn't exist",
@@ -127,7 +143,8 @@ ERROR_FAMILY_SYNS = {
         "difference", "discrepancy", "not equal"
     ),
     "LOCKED": (
-        "locked", "status locked", "blocked", "read only", "read-only", "frozen", "freeze"
+        "locked", "status locked", "blocked", "read only", "read-only",
+        "frozen", "freeze"
     ),
     "PERMISSION": (
         "permission", "permissions", "access denied", "not authorized",
@@ -146,7 +163,6 @@ 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()
     low_norm = re.sub(r"[^\w\s]", " ", low)
     low_norm = re.sub(r"\s+", " ", low_norm).strip()
@@ -181,30 +197,28 @@ def _ensure_numbering(text: str) -> str:
     if not lines:
         return text or ""
 
-    # Collapse lines into a block and then split on common step markers
     para = " ".join(lines).strip()
     if not para:
         return ""
 
-    # 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:
+    # 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:
+
     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 = tmp if len(tmp) > 1 else [seg.strip() for seg in re.split(r"(?<=[.!?])\s+", para) if seg.strip()]
 
-    # 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"(?:\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(),
@@ -212,20 +226,22 @@ def _ensure_numbering(text: str) -> str:
         )
 
     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) ---
 def _norm_text(s: str) -> str:
     s = (s or "").lower()
     s = re.sub(r"[^\w\s]", " ", s)
@@ -237,19 +253,21 @@ 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).
-    Safe for circled digits, '1.' styles, and bullets.
     """
     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*", "", ln)
+        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())
     tb = set(_norm_text(b).split())
     if not ta or not tb:
@@ -313,175 +331,6 @@ def _format_steps_as_numbered(steps: list) -> str:
     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.
-    Generic (SOP-agnostic) scoring:
-      1) error-family match (NOT_FOUND/MISMATCH/LOCKED/PERMISSION/TIMEOUT/SYNC),
-      2) anchored starts (line begins with error heading),
-      3) multi-word overlap (bigrams/trigrams),
-      4) token overlap,
-      5) formatting bonus for bullets/headings.
-
-    Returns exactly `max_lines` best-scoring lines (defaults to 1).
-    """
-    def _norm(s: str) -> str:
-        s = (s or "").lower()
-        s = re.sub(r"[^\w\s]", " ", s)
-        s = re.sub(r"\s+", " ", s).strip()
-        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)]
-
-    def _families_for(s: str) -> set:
-        low = _norm(s)
-        fams = set()
-        for fam, syns in ERROR_FAMILY_SYNS.items():
-            if any(k in low for k in syns):
-                fams.add(fam)
-        return fams
-
-    q = _norm(query)
-    q_tokens = [t for t in q.split() if len(t) > 1]
-    q_bi = _ngrams(q_tokens, 2)
-    q_tri = _ngrams(q_tokens, 3)
-    q_fams = _families_for(query)
-
-    lines = _normalize_lines(text)
-    if not lines:
-        return (text or "").strip()
-
-    scored: List[Tuple[float, str]] = []
-    for ln in lines:
-        ln_norm = _norm(ln)
-        ln_fams = _families_for(ln)
-
-        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 ""
-        if (first3 and ln_norm.startswith(first3)) or (first2 and ln_norm.startswith(first2)):
-            anchored = 1.0
-
-        bigram_hits = sum(1 for bg in q_bi if bg and bg in ln_norm)
-        trigram_hits = sum(1 for tg in q_tri if tg and tg in ln_norm)
-        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
-
-        score = (
-            1.70 * fam_overlap +
-            1.00 * anchored +
-            0.80 * trigram_hits +
-            0.55 * bigram_hits +
-            0.40 * exact_phrase +
-            0.30 * token_overlap
-        )
-
-        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)):
-            score += 0.15
-
-        scored.append((score, ln))
-
-    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)
-    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():
-        return "It looks like you may not have access for this action. Please verify your WMS role/permission with your supervisor or IT."
-    if ("permission" in line.lower()) or ("access" in line.lower()) or ("authorization" in line.lower()):
-        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"
-    if re.search(r"[\u0900-\u097F]", msg or ""):  # Hindi
-        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?"
-    )
-
-
-def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[str, str]:
-    issue = (issue_text or "").strip()
-    resolved = (resolved_text or "").strip()
-    short_desc = issue[:100] if issue else (resolved[:100] or "Issue resolved (user confirmation)")
-    long_desc = (
-        f"User reported: \"{issue}\". "
-        f"User confirmation: \"{resolved}\". "
-        f"Tracking record created automatically by NOVA."
-    ).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",
-        "create incident", "create an incident", "raise incident", "raise an incident", "open incident", "open an incident",
-        "log ticket", "log an incident", "generate ticket", "create snow ticket", "raise snow ticket",
-        "raise service now ticket", "create service now ticket", "raise sr", "open sr",
-    ]
-    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)
-    has_ticket_marker = (
-        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+)"
-    ]
-    for pat in patterns:
-        m = re.search(pat, msg_norm, flags=re.IGNORECASE)
-        if m:
-            val = m.group(1).strip()
-            if val:
-                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",
-        "it's working", "working now", "works now", "fixed", "sorted",
-        "ok now", "fine now", "all good", "all set", "thanks works", "thank you it works", "back to normal",
-    ]
-    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",
-        "didn't work", "doesn't work", "no change", "not fixed", "still failing", "failed again", "broken", "fail",
-    ]
-    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]]:
     STRICT_OVERLAP = 3
     MAX_SENTENCES_STRICT = 4
@@ -494,16 +343,18 @@ 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+", 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)
     matched_exact, matched_any = [], []
     for s in sentences:
@@ -514,28 +365,25 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
             matched_exact.append(s)
         elif overlap > 0:
             matched_any.append(s)
+
     if matched_exact:
         kept = matched_exact[:MAX_SENTENCES_STRICT]
         return "\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)}
+
     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.
-    """
     kept: List[str] = []
     for ln in _normalize_lines(text):
-        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
+        if len(kept) >= max_lines:
+            break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
 
@@ -560,13 +408,15 @@ def _extract_escalation_line(text: str) -> Optional[str]:
     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 = []
+
+    block: List[str] = []
     if start_idx is not None:
         for j in range(start_idx, min(len(lines), start_idx + 6)):
             if not lines[j].strip():
@@ -574,11 +424,14 @@ 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:
@@ -588,120 +441,92 @@ def _extract_escalation_line(text: str) -> Optional[str]:
         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 _classify_resolution_llm(user_message: str) -> bool:
-    if not GEMINI_API_KEY:
-        return False
-    prompt = f"""Classify if the following user message indicates that the issue is resolved or working now.
-Return only 'true' or 'false'.
-Message: {user_message}"""
-    headers = {"Content-Type": "application/json"}
-    payload = {"contents": [{"parts": [{"text": prompt}]}]}
-    try:
-        resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=12, verify=GEMINI_SSL_VERIFY)
-        data = resp.json()
-        text = (
-            data.get("candidates", [{}])[0]
-              .get("content", {})
-              .get("parts", [{}])[0]
-              .get("text", "")
-        )
-        return "true" in (text or "").strip().lower()
-    except Exception:
-        return False
+def _detect_language_hint(msg: str) -> Optional[str]:
+    if re.search(r"[\u0B80-\u0BFF]", msg or ""):  # Tamil
+        return "Tamil"
+    if re.search(r"[\u0900-\u097F]", msg or ""):  # Hindi
+        return "Hindi"
+    return None
 
 
-def _set_incident_resolved(sys_id: str) -> bool:
-    try:
-        token = get_valid_token()
-        instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
-        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)
-                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 _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?"
+    )
 
-        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,
-            "close_notes": close_notes_val,
-            "caller_id": caller_sysid,
-            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
-            "work_notes": "Auto-resolve set by NOVA.",
-            "resolved_by": resolved_by_sysid,
-            "assignment_group": assign_group,
-        })
-        respA = requests.patch(url, headers=headers, json=payload_A, verify=VERIFY_SSL, timeout=25)
-        if respA.status_code in (200, 204):
-            return True
-        print(f"[SN PATCH resolve A] status={respA.status_code} body={respA.text[:500]}")
+def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[str, str]:
+    issue = (issue_text or "").strip()
+    resolved = (resolved_text or "").strip()
+    short_desc = issue[:100] if issue else (resolved[:100] or "Issue resolved (user confirmation)")
+    long_desc = (
+        f'User reported: "{issue}". '
+        f'User confirmation: "{resolved}". '
+        f"Tracking record created automatically by NOVA."
+    ).strip()
+    return short_desc, long_desc
 
-        payload_B = clean({
-            "state": "Resolved",
-            "close_code": close_code_val,
-            "close_notes": close_notes_val,
-            "caller_id": caller_sysid,
-            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
-            "work_notes": "Auto-resolve set by NOVA.",
-            "resolved_by": resolved_by_sysid,
-            "assignment_group": assign_group,
-        })
-        respB = requests.patch(url, headers=headers, json=payload_B, verify=VERIFY_SSL, timeout=25)
-        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({
-            "state": "6",
-            code_field: close_code_val,
-            notes_field: close_notes_val,
-            "caller_id": caller_sysid,
-            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
-            "work_notes": "Auto-resolve set by NOVA.",
-            "resolved_by": resolved_by_sysid,
-            "assignment_group": assign_group,
-        })
-        respC = requests.patch(url, headers=headers, json=payload_C, verify=VERIFY_SSL, timeout=25)
-        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
+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",
+        "create incident", "create an incident", "raise incident", "raise an incident", "open incident", "open an incident",
+        "log ticket", "log an incident", "generate ticket", "create snow ticket", "raise snow ticket",
+        "raise service now ticket", "create service now ticket", "raise sr", "open sr",
+    ]
+    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)
+    has_ticket_marker = (
+        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+)"
+    ]
+    for pat in patterns:
+        m = re.search(pat, msg_norm, flags=re.IGNORECASE)
+        if m:
+            val = m.group(1).strip()
+            if val:
+                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",
+        "it's working", "working now", "works now", "fixed", "sorted",
+        "ok now", "fine now", "all good", "all set", "thanks works", "thank you it works", "back to normal",
+    ]
+    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",
+        "didn't work", "doesn't work", "no change", "not fixed", "still failing", "failed again", "broken", "fail",
+    ]
+    return any(p in msg_norm for p in neg_phrases)
 
 
-# ------------------------------ Prereq helper ------------------------------
 def _find_prereq_section_text(best_doc: str) -> str:
-    """
-    Return the prerequisites section text, trying common heading variants.
-    Generic for future SOPs—no document-specific keywords.
-    """
+    """Return the prerequisites section text, trying common heading variants."""
     variants = [
         "Pre-Requisites",
         "Prerequisites",
@@ -716,13 +541,17 @@ def _find_prereq_section_text(best_doc: str) -> str:
     return ""
 
 
-# ------------------------------ Health ------------------------------
+# ------------------------------------------------------------------------------
+# Health
+# ------------------------------------------------------------------------------
 @app.get("/")
 async def health_check():
     return {"status": "ok"}
 
 
-# ------------------------------ Chat ------------------------------
+# ------------------------------------------------------------------------------
+# Chat
+# ------------------------------------------------------------------------------
 @app.post("/chat")
 async def chat_with_ai(input_data: ChatInput):
     assist_followup: Optional[str] = None
@@ -752,6 +581,7 @@ async def chat_with_ai(input_data: ChatInput):
         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)
@@ -846,6 +676,7 @@ 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}"
@@ -853,10 +684,12 @@ 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"
@@ -876,12 +709,15 @@ async def chat_with_ai(input_data: ChatInput):
             except Exception as e:
                 raise HTTPException(status_code=500, detail=safe_str(e))
 
+        # -----------------------------
         # 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", [])
         distances = kb_results.get("distances", [])
         combined = kb_results.get("combined_scores", [])
+
         items: List[Dict[str, Any]] = []
         for i, doc in enumerate(documents):
             text = doc.strip() if isinstance(doc, str) else ""
@@ -899,11 +735,18 @@ 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 {}
@@ -920,10 +763,11 @@ async def chat_with_ai(input_data: ChatInput):
         if detected_intent == "neutral" and any(t in msg_low for t in PREREQ_TERMS):
             detected_intent = "prereqs"
 
-        # Force errors intent for permissions
+        # Permissions force
         PERM_QUERY_TERMS = [
             "permission", "permissions", "access", "access right", "authorization", "authorisation",
-            "role", "role access", "security", "security profile", "privilege", "not allowed", "not authorized", "denied",
+            "role", "role access", "security", "security profile", "privilege",
+            "not allowed", "not authorized", "denied",
         ]
         is_perm_query = any(t in msg_norm for t in PERM_QUERY_TERMS)
         if is_perm_query:
@@ -938,24 +782,14 @@ async def chat_with_ai(input_data: ChatInput):
         if detected_intent == "neutral" and any(h in sec_title for h in PREREQ_HEADINGS):
             detected_intent = "prereqs"
 
-        # --- Steps nudge: "how to / perform" + receiving/inbound => steps intent
-        STEPS_TERMS = ("how to", "procedure", "perform", "steps", "do", "navigate")
-        RECEIVING_TERMS = ("inbound", "receiving", "goods receipt", "grn")
-
-        mod_tags = ((top_meta or {}).get("module_tags") or "").lower()
-
-        looks_like_steps_query = any(t in msg_low for t in STEPS_TERMS)
-        looks_like_receiving = (
-            any(t in msg_low for t in RECEIVING_TERMS)
-            or "receiving" in mod_tags
-            or "inbound" in sec_title
-            or "receiving" in sec_title
-        )
-
-        if detected_intent in ("neutral", "prereqs") and looks_like_steps_query and looks_like_receiving:
-            detected_intent = "steps"
+        # ---- FORCE STEPS for "what's next" / "next step" queries ----
+        try:
+            if _detect_next_intent(input_data.user_message):
+                detected_intent = "steps"
+        except Exception:
+            pass
 
-        # --- Meaning-aware SOP gating ---
+        # Gating
         def _contains_any(s: str, keywords: tuple) -> bool:
             low = (s or "").lower()
             return any(k in low for k in keywords)
@@ -967,9 +801,9 @@ async def chat_with_ai(input_data: ChatInput):
             "asn", "grn", "pick", "picking"
         )
         ACTION_OR_ERROR_TERMS = (
-            "how to", "procedure", "perform",  # added
+            "how to", "procedure", "perform",
             "close", "closing", "open", "navigate", "scan", "confirm", "generate", "update",
-            "receive", "receiving",            # added
+            "receive", "receiving",
             "error", "issue", "fail", "failed", "not working", "locked", "mismatch",
             "access", "permission", "status"
         )
@@ -982,17 +816,15 @@ async def chat_with_ai(input_data: ChatInput):
         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"))
 
-        # Bypass gate when strong steps signals are present for Receiving module
-        strong_steps_bypass = looks_like_steps_query and looks_like_receiving
+        strong_steps_bypass = True  # next-step override already set steps; allow
         strong_error_signal = len(_detect_error_families(msg_low)) > 0
-        if (weak_domain_only or (low_context_hit and not combined_ok)) \
-            and not strong_steps_bypass \
-            and not (strong_error_signal or generic_error_signal):
 
+        if (weak_domain_only or (low_context_hit and not combined_ok)) \
+           and not strong_steps_bypass \
+           and not (strong_error_signal or generic_error_signal):
             return {
                 "bot_response": _build_clarifying_message(),
                 "status": "NO_KB_MATCH",
@@ -1012,79 +844,89 @@ async def chat_with_ai(input_data: ChatInput):
                     "has_any_action_or_error": has_any_action_or_error,
                     "strong_steps_bypass": strong_steps_bypass,
                     "strong_error_signal": strong_error_signal,
-                    "generic_error_signal": generic_error_signal
+                    "generic_error_signal": generic_error_signal,
                 },
             }
 
         # Build SOP context if allowed
-        if is_perm_query:
-            detected_intent = "errors"
-
-        escalation_line = None  # SOP escalation candidate
-        full_errors = None      # keep for possible escalation extraction
+        escalation_line: Optional[str] = None
+        full_errors: Optional[str] = None
         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 full_steps:
-                    # 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
+        context_preformatted = False
+
+        if best_doc and 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 full_steps:
+                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:
+                    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:
-                        # 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)
-                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)
+                        context = _format_steps_as_numbered(next_only)
+                        next_step_applied = True
+                        next_step_info = {"count": len(next_only)}
+                        context_preformatted = True
+                else:
+                    context = full_steps
+                    context_preformatted = False
+
+                # clear filter info for debug clarity
+                filt_info = {'mode': None, 'matched_count': None, 'all_sentences': None}
+                context_found = True
+
+        elif best_doc and detected_intent == "errors":
+            full_errors = get_best_errors_section_text(best_doc)
+            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:
+                    is_specific_error = len(_detect_error_families(msg_low)) > 0
+                    if is_specific_error:
+                        context = _filter_context_for_query(ctx_err, input_data.user_message)[0]
                     else:
-                        # Decide specific vs generic:
-                        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)
-                        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)]
-                            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."
-                            )
-                    escalation_line = _extract_escalation_line(full_errors)
-
-            elif detected_intent == "prereqs":
-                full_prereqs = _find_prereq_section_text(best_doc)
-                if full_prereqs:
-                    context = full_prereqs.strip()
+                        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)
+                        ]
+                        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."
+                        )
+                escalation_line = _extract_escalation_line(full_errors)
+
+        elif best_doc and detected_intent == "prereqs":
+            full_prereqs = _find_prereq_section_text(best_doc)
+            if full_prereqs:
+                context = full_prereqs.strip()
+                context_found = True
 
+        else:
+            # Neutral or other intents: use filtered context
+            context = filtered_text
+
+        # Language hint & paraphrase (for 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.
@@ -1095,10 +937,12 @@ 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 = ""
         http_code = 0
+
         if use_gemini and GEMINI_API_KEY:
             try:
                 resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=25, verify=GEMINI_SSL_VERIFY)
@@ -1116,23 +960,19 @@ Return ONLY the rewritten guidance."""
 
         # Deterministic local formatting
         if detected_intent == "steps":
-            # 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:
+            if context_preformatted:
                 bot_text = context
             else:
                 bot_text = _ensure_numbering(context)
-
         elif detected_intent == "errors":
-            if not bot_text.strip() or http_code == 429:
+            if not (bot_text or "").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
 
-        # If the user explicitly asks to escalate, append escalation even in 'steps' intent
+        # Append escalation if explicitly requested even in steps mode
         needs_escalation = (" escalate" in msg_norm) or ("escalation" in msg_norm)
         if needs_escalation and best_doc:
             esc_text = get_escalation_text(best_doc)
@@ -1142,7 +982,7 @@ Return ONLY the rewritten guidance."""
             if line:
                 bot_text = (bot_text or "").rstrip() + "\n\n" + line
 
-        # Guarantee non-empty bot response
+        # Non-empty guarantee
         if not (bot_text or "").strip():
             if context.strip():
                 bot_text = context.strip()
@@ -1155,9 +995,11 @@ 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"
+
         options = [{"type": "yesno", "title": "Share details or raise a ticket?"}] if status == "PARTIAL" else []
 
         return {
@@ -1175,23 +1017,23 @@ Return ONLY the rewritten guidance."""
                 "best_distance": best_distance,
                 "best_combined": best_combined,
                 "http_status": http_code,
-                "filter_mode": filt_info.get("mode"),
-                "matched_count": filt_info.get("matched_count"),
+                "filter_mode": filt_info.get("mode") if isinstance(filt_info, dict) else None,
+                "matched_count": filt_info.get("matched_count") if isinstance(filt_info, dict) else None,
                 "user_intent": detected_intent,
                 "best_doc": best_doc,
-                "next_step": {
-                    "applied": next_step_applied,
-                    "info": next_step_info,
-                },
+                "next_step": {"applied": next_step_applied, "info": next_step_info},
             },
         }
+
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
 
-# ------------------------------ Ticket description generation ------------------------------
+# ------------------------------------------------------------------------------
+# Ticket description generation
+# ------------------------------------------------------------------------------
 @app.post("/generate_ticket_desc")
 async def generate_ticket_desc_ep(input_data: TicketDescInput):
     try:
@@ -1211,13 +1053,16 @@ 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 {
@@ -1226,11 +1071,14 @@ 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 ------------------------------
+# ------------------------------------------------------------------------------
+# Incident status
+# ------------------------------------------------------------------------------
 @app.post("/incident_status")
 async def incident_status(input_data: TicketStatusInput):
     try:
@@ -1238,7 +1086,9 @@ 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)
@@ -1252,10 +1102,12 @@ 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"
@@ -1267,11 +1119,121 @@ 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 ------------------------------
+# ------------------------------------------------------------------------------
+# Incident creation
+# ------------------------------------------------------------------------------
+def _classify_resolution_llm(user_message: str) -> bool:
+    if not GEMINI_API_KEY:
+        return False
+    prompt = f"""Classify if the following user message indicates that the issue is resolved or working now.
+Return only 'true' or 'false'.
+Message: {user_message}"""
+    headers = {"Content-Type": "application/json"}
+    payload = {"contents": [{"parts": [{"text": prompt}]}]}
+    try:
+        resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=12, verify=GEMINI_SSL_VERIFY)
+        data = resp.json()
+        text = (
+            data.get("candidates", [{}])[0]
+            .get("content", {})
+            .get("parts", [{}])[0]
+            .get("text", "")
+        )
+        return "true" in (text or "").strip().lower()
+    except Exception:
+        return False
+
+
+def _set_incident_resolved(sys_id: str) -> bool:
+    try:
+        token = get_valid_token()
+        instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
+        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)
+                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,
+            "close_notes": close_notes_val,
+            "caller_id": caller_sysid,
+            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
+            "work_notes": "Auto-resolve set by NOVA.",
+            "resolved_by": resolved_by_sysid,
+            "assignment_group": assign_group,
+        })
+        respA = requests.patch(url, headers=headers, json=payload_A, verify=VERIFY_SSL, timeout=25)
+        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,
+            "close_notes": close_notes_val,
+            "caller_id": caller_sysid,
+            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
+            "work_notes": "Auto-resolve set by NOVA.",
+            "resolved_by": resolved_by_sysid,
+            "assignment_group": assign_group,
+        })
+        respB = requests.patch(url, headers=headers, json=payload_B, verify=VERIFY_SSL, timeout=25)
+        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({
+            "state": "6",
+            code_field: close_notes_val,  # adjust if custom fields
+            notes_field: close_notes_val,
+            "caller_id": caller_sysid,
+            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
+            "work_notes": "Auto-resolve set by NOVA.",
+            "resolved_by": resolved_by_sysid,
+            "assignment_group": assign_group,
+        })
+        respC = requests.patch(url, headers=headers, json=payload_C, verify=VERIFY_SSL, timeout=25)
+        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: