Update main.py

main.py

@@ -1,7 +1,8 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-import os, json, re, requests, builtins
+import os
+import json
+import re
+import requests
+import builtins
 from typing import Optional, Any, Dict, List, Tuple
 from contextlib import asynccontextmanager
 from fastapi import FastAPI, HTTPException
@@ -14,17 +15,15 @@ from services.kb_creation import (
     collection,
     ingest_documents,
     hybrid_search_knowledge_base,
-    get_section_text,
-    get_best_steps_section_text,
+    get_section_text,             # NEW
+    get_best_steps_section_text,  # NEW
 )
+
 from services.login import router as login_router
 from services.generate_ticket import get_valid_token, create_incident
 
 VERIFY_SSL = os.getenv("SERVICENOW_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
-
-# --------------------------------------------------------
-# Utilities
-# --------------------------------------------------------
+GEMINI_SSL_VERIFY = os.getenv("GEMINI_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
 
 def safe_str(e: Any) -> str:
     try:
@@ -40,13 +39,17 @@ async def lifespan(app: FastAPI):
     try:
         folder_path = os.path.join(os.getcwd(), "documents")
         if collection.count() == 0:
+            print("🔍 KB empty. Running ingestion...")
             ingest_documents(folder_path)
+        else:
+            print(f"✅ KB already populated with {collection.count()} entries. Skipping ingestion.")
     except Exception as e:
-        print(f"[lifespan] KB ingestion failed: {safe_str(e)}")
+        print(f"⚠️ KB ingestion failed: {safe_str(e)}")
     yield
 
 app = FastAPI(lifespan=lifespan)
 app.include_router(login_router)
+
 origins = ["https://chatbotnova-chatbot-frontend.hf.space"]
 app.add_middleware(
     CORSMiddleware,
@@ -56,9 +59,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# --------------------------------------------------------
-# Models
-# --------------------------------------------------------
 class ChatInput(BaseModel):
     user_message: str
     prev_status: Optional[str] = None
@@ -76,11 +76,183 @@ class TicketStatusInput(BaseModel):
     sys_id: Optional[str] = None
     number: Optional[str] = None
 
-# --------------------------------------------------------
-# KB filters & extractors (no LLM)
-# --------------------------------------------------------
+STATE_MAP = {
+    "1": "New",
+    "2": "In Progress",
+    "3": "On Hold",
+    "6": "Resolved",
+    "7": "Closed",
+    "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}"
+)
+
+def extract_kb_context(kb_results: Optional[Dict[str, Any]], top_chunks: int = 2) -> Dict[str, Any]:
+    if not kb_results or not isinstance(kb_results, dict):
+        return {"context": "", "sources": [], "top_hits": [], "context_found": False, "best_score": None, "best_combined": None}
+
+    documents = kb_results.get("documents") or []
+    metadatas = kb_results.get("metadatas") or []
+    distances = kb_results.get("distances") or []
+    combined = kb_results.get("combined_scores") or []
+
+    items = []
+    for i, doc in enumerate(documents):
+        text = doc.strip() if isinstance(doc, str) else ""
+        if not text:
+            continue
+        meta = metadatas[i] if i < len(metadatas) and isinstance(metadatas[i], dict) else {}
+        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
+        items.append({"text": text, "meta": m})
+
+    selected = items[:max(1, top_chunks)]
+    context = "\n\n---\n\n".join([s["text"] for s in selected]) if selected else ""
+    sources = [s["meta"] for s in selected]
+
+    best_distance = None
+    if distances:
+        try:
+            best_distance = min([d for d in distances if d is not None])
+        except Exception:
+            best_distance = None
+    best_combined = None
+    if combined:
+        try:
+            best_combined = max([c for c in combined if c is not None])
+        except Exception:
+            best_combined = None
+
+    return {
+        "context": context,
+        "sources": sources,
+        "top_hits": [],
+        "context_found": bool(selected),
+        "best_score": best_distance,
+        "best_combined": best_combined,
+    }
+
+def _strip_any_source_lines(text: str) -> str:
+    lines = text.splitlines()
+    kept = []
+    for ln in lines:
+        if re.match(r"^\s*source\s*:", ln, flags=re.IGNORECASE):
+            continue
+        kept.append(ln)
+    return "\n".join(kept).strip()
+
+def _build_clarifying_message() -> str:
+    return (
+        "I couldn’t find matching content in the KB yet. To help me narrow it down, please share:\n\n"
+        "• Module/area (e.g., Picking, Receiving, Trailer Close)\n"
+        "• Exact error message text/code (copy-paste)\n"
+        "• IDs involved (Order#, Load ID, Shipment#)\n"
+        "• Warehouse/site & environment (prod/test)\n"
+        "• When it started and how many users are impacted\n\n"
+        "Reply with these details and I’ll search again."
+    )
+
+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 _is_feedback_message(msg_norm: str) -> bool:
+    feedback_phrases = [
+        "issue not resolved", "not resolved", "still not working",
+        "same issue", "no change", "didn't work", "doesn't work",
+        "not fixed", "still failing", "failed again",
+    ]
+    return any(p in msg_norm for p in feedback_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"]
+    if not any(k in msg_norm for k in status_keywords):
+        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 _classify_resolution_llm(user_message: str) -> bool:
+    if not GEMINI_API_KEY:
+        return False
+    prompt = (
+        "Classify if the following user message indicates that the issue is resolved or working now.\n"
+        "Return only 'true' or 'false'.\n\n"
+        f"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 _is_generic_issue(msg_norm: str) -> bool:
+    generic_phrases = [
+        "issue", "have an issue", "having an issue", "got an issue",
+        "problem", "have a problem", "help", "need help", "support",
+        "need support", "please help", "need assistance", "assist me",
+        "facing issue", "facing a problem", "got a problem"
+    ]
+    return any(p == msg_norm or p in msg_norm for p in generic_phrases) or len(msg_norm.split()) <= 2
+
+# ---------- Query-normalized, order-preserving filter ----------
 STRICT_OVERLAP = 3
-MAX_SENTENCES_CONCISE = 6
+MAX_SENTENCES_STRICT = 4
+MAX_SENTENCES_CONCISE = 3
 
 def _normalize_for_match(text: str) -> str:
     t = (text or "").lower()
@@ -89,7 +261,7 @@ def _normalize_for_match(text: str) -> 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]
 
 def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str, Any]]:
@@ -111,7 +283,7 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
         elif overlap > 0:
             matched_any.append(s)
     if matched_exact:
-        kept = matched_exact  # keep many lines; gate later
+        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]
@@ -119,19 +291,29 @@ 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)}
 
-STEP_LINE_REGEX = re.compile(r"^\s*(?:\d+[\.)]\s+|[•\-]\s+)", re.IGNORECASE)
+# ---------- intent & action specific extractors ----------
+STEP_LINE_REGEX = re.compile(r"^\s*(?:\d+[\.\)]\s+|[•\-]\s+)", re.IGNORECASE)
 NAV_LINE_REGEX  = re.compile(r"(navigate\s+to|>\s*)", re.IGNORECASE)
+
 PROCEDURE_VERBS = [
-    "log in","select","scan","verify","confirm","print",
-    "move","complete","click","open","navigate","choose",
-    "enter","update","save","delete","create","attach","assign"
+    "log in", "select", "scan", "verify", "confirm", "print",
+    "move", "complete", "click", "open", "navigate", "choose",
+    "enter", "update", "save", "delete", "create", "attach", "assign"
 ]
-VERB_START_REGEX   = re.compile(r"^\s*(?:" + "|".join([re.escape(v) for v in PROCEDURE_VERBS]) + r")\b", re.IGNORECASE)
-NON_PROC_ANY_REGEX = re.compile("|".join([re.escape(v) for v in [
-    "to ensure","as per","purpose","pre-requisites","prerequisites","overview","introduction",
-    "organized manner","structured","help users","objective"
-]]), re.IGNORECASE)
-ACTION_SYNS_FLAT   = {"create":["create","creation","add","new","generate"],"update":["update","modify","change","edit"],"delete":["delete","remove"],"navigate":["navigate","go to","open"]}
+VERB_START_REGEX = re.compile(r"^\s*(?:" + "|".join([re.escape(v) for v in PROCEDURE_VERBS]) + r")\b", re.IGNORECASE)
+
+NON_PROC_PHRASES = [
+    "to ensure", "as per", "purpose", "pre-requisites", "prerequisites", "overview", "introduction",
+    "organized manner", "structured", "help users", "objective"
+]
+NON_PROC_ANY_REGEX = re.compile("|".join([re.escape(v) for v in NON_PROC_PHRASES]), re.IGNORECASE)
+
+ACTION_SYNS_FLAT = {
+    "create": ["create", "creation", "add", "new", "generate"],
+    "update": ["update", "modify", "change", "edit"],
+    "delete": ["delete", "remove"],
+    "navigate": ["navigate", "go to", "open"],
+}
 
 def _action_in_line(ln: str, target_actions: List[str]) -> bool:
     s = (ln or "").lower()
@@ -148,7 +330,7 @@ def _is_procedural_line(ln: str) -> bool:
     if NON_PROC_ANY_REGEX.search(s):
         return False
     if STEP_LINE_REGEX.match(s):
-        if s.lstrip().startswith(("•","-")):
+        if s.lstrip().startswith(("•", "-")):
             return bool(VERB_START_REGEX.search(s) or NAV_LINE_REGEX.search(s))
         return True
     if VERB_START_REGEX.match(s):
@@ -157,206 +339,137 @@ def _is_procedural_line(ln: str) -> bool:
         return True
     return False
 
-def _extract_steps_only(text: str, max_lines: Optional[int] = None, target_actions: Optional[List[str]] = None) -> str:
+def _extract_steps_only(text: str, max_lines: Optional[int] = 12, target_actions: Optional[List[str]] = None) -> str:
     lines = [ln.strip() for ln in (text or "").splitlines() if ln.strip()]
-    kept, seen = [], set()
+    kept = []
     for ln in lines:
         if _is_procedural_line(ln):
-            normalized = re.sub(r"^\s*(?:\d+[\.)]\s+|[•\-]\s+)", "", ln).strip().lower()
-            if normalized in seen:
-                continue
-            if target_actions and not _action_in_line(ln, target_actions):
-                continue
+            if target_actions:
+                if not _action_in_line(ln, target_actions):
+                    continue
             kept.append(ln)
-            seen.add(normalized)
             if max_lines is not None and len(kept) >= max_lines:
                 break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
-# ---- Errors extractor ----
-def _extract_errors_only(text: str, max_lines: int = 12) -> str:
+def _extract_navigation_only(text: str, max_lines: int = 6) -> str:
     lines = [ln.strip() for ln in (text or "").splitlines() if ln.strip()]
-    kept: List[str] = []
+    kept = []
     for ln in lines:
-        if STEP_LINE_REGEX.match(ln) or ln.lower().startswith(("error", "resolution", "fix", "verify", "check")):
+        if NAV_LINE_REGEX.search(ln) or ln.lower().startswith("log in"):
             kept.append(ln)
             if len(kept) >= max_lines:
                 break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
-# ---- Escalation extractor ----
-ESCALATION_REGEX = re.compile(r"^\s*Escalation Path|\s+→\s+", re.IGNORECASE)
-
-def _extract_escalation_only(text: str, max_lines: int = 3) -> str:
+def _extract_errors_only(text: str, max_lines: int = 10) -> str:
     lines = [ln.strip() for ln in (text or "").splitlines() if ln.strip()]
     kept = []
     for ln in lines:
-        if ESCALATION_REGEX.search(ln):
+        if STEP_LINE_REGEX.match(ln) or ln.lower().startswith(("error", "resolution", "fix", "verify", "check")):
             kept.append(ln)
             if len(kept) >= max_lines:
                 break
-    return "\n".join(kept).strip()
-
-# ---- merge number-only lines helper ----
-def _merge_number_only_lines(lines: List[str]) -> List[str]:
-    merged: List[str] = []
-    i, n = 0, len(lines)
-    def is_number_only(s: str) -> bool:
-        return bool(re.fullmatch(r"\s*\d+\s*", s or ""))
-    while i < n:
-        curr = (lines[i] or "").strip()
-        if is_number_only(curr):
-            j = i + 1
-            while j < n and is_number_only(lines[j]):
-                j += 1
-            if j < n:
-                merged.append(f"{curr.strip()}. {lines[j].strip()}")
-                i = j + 1
-            else:
-                i += 1
-        else:
-            merged.append(curr)
-            i += 1
-    return merged
-
-# ---- strip any existing leading numbering/bullets ----
-def _strip_leading_mark(s: str) -> str:
-    return re.sub(r"^\s*(?:\d+[\.)]\s+|[•\-]\s+)", "", (s or "")).strip()
-
-# --------------------------------------------------------
-# Conversation intents & helpers
-# --------------------------------------------------------
-def _is_incident_intent(msg_norm: str) -> bool:
-    intents = [
-        "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 intents)
-
-def _is_generic_issue(msg_norm: str) -> bool:
-    generic = [
-        "issue","have an issue","having an issue","got an issue","problem","have a problem","help","need help","support",
-        "need support","please help","need assistance","assist me","facing issue","facing a problem","got a problem"
-    ]
-    return any(p == msg_norm or p in msg_norm for p in generic) or len(msg_norm.split()) <= 2
-
-def _is_negative_feedback(msg_norm: str) -> bool:
-    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","not solved","same issue"
-    ]
-    return any(p in msg_norm for p in phrases)
-
-# Parse status intent inside chat (e.g., "status INC0012345")
-def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
-    keywords = ["status", "ticket status", "incident status", "check status", "check ticket status", "check incident status"]
-    if not any(k in msg_norm for k in keywords):
-        return {}
-    # Try to capture INC number
-    m = re.search(r"(inc\d+)", msg_norm, flags=re.IGNORECASE)
-    if m:
-        val = m.group(1).strip().upper()
-        return {"number": val}
-    # Ask the user for number if not present
-    return {"ask_number": True}
-
-# --------------------------------------------------------
-# Error/escalation friendly composition
-# --------------------------------------------------------
-def _compose_errors_response(error_lines: List[str], escalation_lines: List[str]) -> str:
-    err = [ln.strip() for ln in (error_lines or []) if ln and ln.strip()]
-    esc = [ln.strip() for ln in (escalation_lines or []) if ln and ln.strip()]
-
-    summary = None
-    joined = " ".join(err).lower()
-    if any(k in joined for k in ["permission","authorized","authorization","role access","not allowed","insufficient"]):
-        summary = (
-            "It looks like your role doesn’t allow Inventory Adjustment right now. "
-            "Please verify you have the required authorization/role enabled. "
-            "If you still cannot proceed, follow the escalation path below."
-        )
+    return "\n".join(kept).strip() if kept else (text or "").strip()
 
-    actions: List[str] = []
-    for ln in err:
-        s = re.sub(r"^\s*(?:\d+[\.)]\s+|[•\-]\s+)", "", ln).strip()
-        s = s.replace("Verify role access", "Verify your role/access in WMS")
-        s = s.replace("Check if cycle count or task is active", "Check if any cycle count/task is locking the location")
-        s = s.replace("Confirm unit of measure setup", "Confirm the item’s UOM setup in master data")
-        if s:
-            actions.append(f"• {s}")
-
-    esc_text = ""
-    if esc:
-        raw = esc[0]
-        clean = re.sub(r"^\s*Escalation Path\s*:?\s*", "", raw, flags=re.IGNORECASE).strip()
-        esc_text = f"\n\n**Escalation Path:** {clean}"
-
-    top = summary or "Here’s how to resolve this:"
-    bullet_block = ("\n" + "\n".join(actions)) if actions else ""
-    return f"{top}{bullet_block}{esc_text}".strip()
-
-# --------------------------------------------------------
-# Health
-# --------------------------------------------------------
+def _format_steps_markdown(lines: List[str]) -> str:
+    """
+    Convert a list of step lines into a clean Markdown numbered list.
+    Keeps original order, trims whitespace, skips empty lines.
+    """
+    items = []
+    for i, ln in enumerate(lines, start=1):
+        s = (ln or "").strip()
+        if not s:
+            continue
+        # If the line already has leading "1. " or "• ", strip it so numbering is consistent
+        s = re.sub(r"^\s*(?:\d+[\.\)]\s+|[•\-]\s+)", "", s).strip()
+        items.append(f"{i}. {s}")
+    return "\n".join(items).strip()
+   
 @app.get("/")
 async def health_check():
     return {"status": "ok"}
 
-# --------------------------------------------------------
-# Chat endpoint
-# --------------------------------------------------------
 @app.post("/chat")
 async def chat_with_ai(input_data: ChatInput):
     try:
         msg_norm = (input_data.user_message or "").lower().strip()
 
-        # --- Negative feedback: proactively offer incident creation
-        if _is_negative_feedback(msg_norm):
+        # --- Yes/No handlers ---
+        if msg_norm in ("yes", "y", "sure", "ok", "okay"):
             return {
-                "bot_response": (
-                    "Sorry it’s still not resolved. I can open a ServiceNow incident to track and escalate.\n\n"
-                    "Please provide:\n• Short Description (one line)\n"
-                    "• Detailed Description (what you tried, exact error text, IDs, site, environment)"
-                ),
-                "status": "PARTIAL",
-                "context_found": False,
-                "ask_resolved": False,
-                "suggest_incident": True,
-                "show_incident_form": True,
+                "bot_response": ("Great! Tell me what you’d like to do next — check another ticket, create an incident, or describe your issue."),
+                "status": "OK",
+                "followup": "You can say: 'create ticket', 'incident status INC0012345', or describe your problem.",
+                "options": [],
+                "debug": {"intent": "continue_conversation"},
+            }
+        if msg_norm in ("no", "no thanks", "nope"):
+            return {
+                "bot_response": "Glad I could help! 👋 If you need anything else later, just let me know.",
+                "status": "OK",
+                "end_chat": True,
                 "followup": None,
-                "top_hits": [], "sources": [],
-                "debug": {"intent": "negative_feedback"},
+                "options": [],
+                "debug": {"intent": "end_conversation"},
             }
 
-        # --- Explicit incident intent: try direct creation if enough details; else show form
+        # --- Resolution ack ---
+        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)
+                result = create_incident(short_desc, long_desc)
+                if isinstance(result, dict) and not result.get("error"):
+                    inc_number = result.get("number", "<unknown>")
+                    sys_id = result.get("sys_id")
+                    resolved_note = ""
+                    if sys_id:
+                        ok = _set_incident_resolved(sys_id)
+                        resolved_note = " (marked Resolved)" if ok else " (could not mark Resolved; please update manually)"
+                    return {
+                        "bot_response": f"✅ Incident created: {inc_number}{resolved_note}",
+                        "status": "OK",
+                        "context_found": False,
+                        "ask_resolved": False,
+                        "suggest_incident": False,
+                        "followup": None,
+                        "top_hits": [],
+                        "sources": [],
+                        "auto_incident": True,
+                        "debug": {"intent": "resolved_ack", "auto_created": True},
+                    }
+                else:
+                    err = (result or {}).get("error", "Unknown error")
+                    return {
+                        "bot_response": f"⚠️ I couldn’t create the tracking incident automatically ({err}).",
+                        "status": "PARTIAL",
+                        "context_found": False,
+                        "ask_resolved": False,
+                        "suggest_incident": True,
+                        "followup": "Shall I create a ticket now?",
+                        "top_hits": [],
+                        "sources": [],
+                        "debug": {"intent": "resolved_ack", "auto_created": False, "error": err},
+                    }
+            except Exception as e:
+                return {
+                    "bot_response": f"⚠️ Something went wrong while creating the tracking incident: {safe_str(e)}",
+                    "status": "PARTIAL",
+                    "context_found": False,
+                    "ask_resolved": False,
+                    "suggest_incident": True,
+                    "followup": "Shall I create a ticket now?",
+                    "top_hits": [],
+                    "sources": [],
+                    "debug": {"intent": "resolved_ack", "exception": True},
+                }
+
+        # --- Incident intent ---
         if _is_incident_intent(msg_norm):
-            # If user message has more than the keywords, attempt immediate creation
-            minimal_phrases = ["create ticket", "create incident", "open ticket", "open incident", "raise ticket", "raise incident"]
-            has_only_minimal = any(msg_norm.strip() == p for p in minimal_phrases)
-            if not has_only_minimal and len(msg_norm.split()) > 3:
-                short_desc = input_data.user_message.strip()[:100]
-                long_desc  = input_data.user_message.strip()
-                try:
-                    result = create_incident(short_desc, long_desc)
-                    if isinstance(result, dict) and not result.get("error"):
-                        inc_number = result.get("number", "<unknown>")
-                        return {
-                            "bot_response": f"✅ Incident created: {inc_number}",
-                            "status": "OK",
-                            "context_found": False,
-                            "ask_resolved": False,
-                            "suggest_incident": False,
-                            "followup": "Is there anything else I can assist you with?",
-                            "top_hits": [], "sources": [],
-                            "debug": {"intent": "create_ticket_direct"},
-                        }
-                except Exception as e:
-                    # Fall back to form if direct creation fails
-                    pass
-            # Prompt for details & show form
             return {
                 "bot_response": (
                     "Okay, let’s create a ServiceNow incident.\n\n"
@@ -364,12 +477,17 @@ async def chat_with_ai(input_data: ChatInput):
                     "• Detailed Description (steps, error text, IDs, site, environment)"
                 ),
                 "status": (input_data.prev_status or "PARTIAL"),
-                "context_found": False, "ask_resolved": False, "suggest_incident": True,
-                "show_incident_form": True, "followup": None, "top_hits": [], "sources": [],
+                "context_found": False,
+                "ask_resolved": False,
+                "suggest_incident": False,
+                "show_incident_form": True,
+                "followup": None,
+                "top_hits": [],
+                "sources": [],
                 "debug": {"intent": "create_ticket"},
             }
 
-        # --- Generic openers
+        # --- Generic opener ---
         if _is_generic_issue(msg_norm):
             return {
                 "bot_response": (
@@ -381,12 +499,16 @@ async def chat_with_ai(input_data: ChatInput):
                     "• When it started and how many users are impacted"
                 ),
                 "status": "NO_KB_MATCH",
-                "context_found": False, "ask_resolved": False, "suggest_incident": False,
-                "followup": "Please reply with the above details.", "top_hits": [], "sources": [],
+                "context_found": False,
+                "ask_resolved": False,
+                "suggest_incident": False,
+                "followup": "Please reply with the above details.",
+                "top_hits": [],
+                "sources": [],
                 "debug": {"intent": "generic_issue"},
             }
 
-        # --- Status intent inside chat
+        # --- Status intent ---
         status_intent = _parse_ticket_status_intent(msg_norm)
         if status_intent:
             if status_intent.get("ask_number"):
@@ -396,12 +518,12 @@ async def chat_with_ai(input_data: ChatInput):
                     "context_found": False,
                     "ask_resolved": False,
                     "suggest_incident": False,
-                    "show_status_form": True,
                     "followup": "Provide the Incident ID and I’ll fetch the status.",
-                    "top_hits": [], "sources": [],
+                    "show_status_form": True,
+                    "top_hits": [],
+                    "sources": [],
                     "debug": {"intent": "status_request_missing_id"},
                 }
-            # fetch
             try:
                 token = get_valid_token()
                 instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
@@ -415,14 +537,13 @@ async def chat_with_ai(input_data: ChatInput):
                 lst = data.get("result", [])
                 result = (lst or [{}])[0] if response.status_code == 200 else {}
                 state_code = builtins.str(result.get("state", "unknown"))
-                state_map = {"1":"New","2":"In Progress","3":"On Hold","6":"Resolved","7":"Closed","8":"Canceled"}
-                state_label = state_map.get(state_code, state_code)
+                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"
-                        f"**Status:** {state_label}\n"
+                        f"**Ticket:** {num} \n"
+                        f"**Status:** {state_label} \n"
                         f"**Issue description:** {short}"
                     ),
                     "status": "OK",
@@ -431,186 +552,167 @@ async def chat_with_ai(input_data: ChatInput):
                     "ask_resolved": False,
                     "suggest_incident": False,
                     "followup": "Is there anything else I can assist you with?",
-                    "top_hits": [], "sources": [],
+                    "top_hits": [],
+                    "sources": [],
                     "debug": {"intent": "status", "http_status": response.status_code},
                 }
             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)
+        kb_ctx = extract_kb_context(kb_results, top_chunks=2)
+        context_raw = kb_ctx.get("context", "") or ""
 
-        # Build a small context window
-        def extract_kb_context(kb_results: Optional[Dict[str, Any]], top_chunks: int = 2) -> Dict[str, Any]:
-            if not kb_results or not isinstance(kb_results, dict):
-                return {"context": "", "sources": [], "top_hits": [], "context_found": False, "best_score": None, "best_combined": None}
-            documents = kb_results.get("documents") or []
-            metadatas = kb_results.get("metadatas") or []
-            distances = kb_results.get("distances") or []
-            combined  = kb_results.get("combined_scores") or []
-            items: List[Dict[str, Any]] = []
-            for i, doc in enumerate(documents):
-                text = doc.strip() if isinstance(doc, str) else ""
-                if not text:
-                    continue
-                meta  = metadatas[i] if i < len(metadatas) and isinstance(metadatas[i], dict) else {}
-                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
-                items.append({"text": text, "meta": m})
-            selected = items[:max(1, top_chunks)]
-            context  = "\n\n---\n\n".join([s["text"] for s in selected]) if selected else ""
-            sources  = [s["meta"] for s in selected]
-            best_distance = None
-            if distances:
-                try:
-                    best_distance = min([d for d in distances if d is not None])
-                except Exception:
-                    best_distance = None
-            best_combined = None
-            if combined:
-                try:
-                    best_combined = max([c for c in combined if c is not None])
-                except Exception:
-                    best_combined = None
-            return {
-                "context": context, "sources": sources, "top_hits": [], "context_found": bool(selected),
-                "best_score": best_distance, "best_combined": best_combined
-            }
-
-        kb_ctx        = extract_kb_context(kb_results, top_chunks=2)
-        context_raw   = kb_ctx.get("context", "") or ""
         filtered_text, filt_info = _filter_context_for_query(context_raw, input_data.user_message)
-
+        context = filtered_text
+        context_found = bool(kb_ctx.get("context_found", False)) and bool(context.strip())
+        best_distance = kb_ctx.get("best_score")
+        best_combined = kb_ctx.get("best_combined")
         detected_intent = kb_results.get("user_intent", "neutral")
-        actions         = kb_results.get("actions", [])
-        best_doc        = kb_results.get("best_doc")
-        best_distance   = kb_ctx.get("best_score")
-        best_combined   = kb_ctx.get("best_combined")
-        top_meta        = (kb_results.get("metadatas") or [{}])[0] if (kb_results.get("metadatas") or []) else {}
-
-        short_query          = len((input_data.user_message or "").split()) <= 4
-        gate_combined_ok     = 0.58 if short_query else 0.55
-        gate_combined_no_kb  = 0.22 if short_query else 0.28
-        gate_distance_no_kb  = 2.0
-
-        exact_by_filter = (filt_info.get('mode') == 'exact' and filt_info.get('matched_count', 0) > 0)
-        high_conf       = (best_combined is not None and best_combined >= gate_combined_ok)
-        exact           = bool(exact_by_filter or high_conf)
-
-        # --- STEPS intent: full SOP steps (numbered)
+        actions = kb_results.get("actions", [])
+        best_doc = kb_results.get("best_doc")
+        top_meta = (kb_results.get("metadatas") or [{}])[0] if (kb_results.get("metadatas") or []) else {}
+
+        # --- FULL SECTION when strongly found & steps intent ---
         if detected_intent == "steps" and best_doc:
+            # prefer full 'Process Steps' section from the best SOP
             full_steps = get_best_steps_section_text(best_doc)
             if not full_steps:
+                # fallback: full text of the top section
                 sec = (top_meta or {}).get("section")
                 if sec:
                     full_steps = get_section_text(best_doc, sec)
             if full_steps:
-                context = _extract_steps_only(full_steps, max_lines=None if exact else MAX_SENTENCES_CONCISE, target_actions=actions)
-            else:
-                context = _extract_steps_only(filtered_text, max_lines=MAX_SENTENCES_CONCISE, target_actions=actions)
-
-            raw_lines = [ln.strip() for ln in context.splitlines() if ln.strip()]
-            if len(raw_lines) == 1:
-                parts = [p.strip() for p in re.split(r"\.\s+(?=[A-Z0-9])", raw_lines[0]) if p.strip()]
-                raw_lines = parts if len(parts) > 1 else raw_lines
-            raw_lines     = _merge_number_only_lines(raw_lines)
-            cleaned_lines = [_strip_leading_mark(ln) for ln in raw_lines]
-            bot_text      = "\n".join([f"{i+1}. {ln}" for i, ln in enumerate(cleaned_lines)])
-
-            status = "OK" if exact else "PARTIAL"
-            return {
-                "bot_response": bot_text,
-                "status": status,
-                "context_found": True,
-                "ask_resolved": (status == "OK"),
-                "suggest_incident": False,
-                "followup": ("Does this match your scenario? I can refine the steps." if status == "PARTIAL" else None),
-                "top_hits": [], "sources": [],
-                "debug": {
-                    "used_chunks": len(context.split("\n\n---\n\n")) if context else 0,
-                    "best_distance": best_distance, "best_combined": best_combined,
-                    "filter_mode": filt_info.get("mode"), "matched_count": filt_info.get("matched_count"),
-                    "user_intent": detected_intent, "actions": actions, "best_doc": best_doc,
-                    "exact": exact, "high_conf": high_conf,
-                },
-            }
-
-        # --- Non-steps intents
-        context = filtered_text
-        if detected_intent == "errors":
-            errs = _extract_errors_only(context, max_lines=MAX_SENTENCES_CONCISE)
-            esc  = _extract_escalation_only(context, max_lines=3)
-            err_lines, esc_lines = _extract_errors_and_escalation(errs + ("\n" + esc if esc else ""))
-            bot_text = _compose_errors_response(err_lines, esc_lines)
-            status = "OK" if exact else "PARTIAL"
-            return {
-                "bot_response": bot_text,
-                "status": status,
-                "context_found": True,
-                "ask_resolved": (status == "OK"),
-                "suggest_incident": False,
-                "followup": ("Does this help? I can refine." if status == "PARTIAL" else None),
-                "top_hits": [], "sources": [],
-                "debug": {
-                    "used_chunks": len(context.split("\n\n---\n\n")) if context else 0,
-                    "best_distance": best_distance,
-                    "best_combined": best_combined,
-                    "filter_mode": filt_info.get("mode"),
-                    "matched_count": filt_info.get("matched_count"),
-                    "user_intent": detected_intent,
-                    "actions": actions,
-                    "best_doc": best_doc,
-                    "exact": exact,
-                    "high_conf": high_conf,
-                },
-            }
-        elif "navigate" in msg_norm or "menu" in msg_norm or "screen" in msg_norm:
-            context = _extract_steps_only(context, max_lines=MAX_SENTENCES_CONCISE)
-
-        # --- No-KB gate
-        if (not context.strip()) or (
-            (best_combined is None or best_combined < gate_combined_no_kb) and (best_distance is None or best_distance >= gate_distance_no_kb)
+                # If confidence is high, return ALL procedural lines (no truncation)
+                high_conf = (best_combined is not None and best_combined >= 0.75)
+                context = _extract_steps_only(full_steps, max_lines=None if high_conf else 20, target_actions=actions)
+
+        # Intent-shaping (secondary; if not already handled above)
+        q = (input_data.user_message or "").lower()
+        if detected_intent == "steps" or any(k in q for k in ["steps", "procedure", "perform", "do", "process"]):
+            context = _extract_steps_only(context, max_lines=None if (best_combined and best_combined >= 0.75) else 12, target_actions=actions)
+        elif detected_intent == "errors" or any(k in q for k in ["error", "issue", "fail", "not working", "resolution", "fix"]):
+            context = _extract_errors_only(context, max_lines=10)
+        elif any(k in q for k in ["navigate", "navigation", "menu", "screen"]):
+            context = _extract_navigation_only(context, max_lines=6)
+
+        # Gating
+        short_query = len((input_data.user_message or "").split()) <= 4
+        gate_combined_no_kb = 0.22 if short_query else 0.28
+        gate_combined_ok = 0.60 if short_query else 0.55
+        gate_distance_no_kb = 2.0
+
+        if (not context_found or not context.strip()) or (
+            (best_combined is None or best_combined < gate_combined_no_kb)
+            and (best_distance is None or best_distance >= gate_distance_no_kb)
         ):
             second_try = (input_data.prev_status or "").upper() == "NO_KB_MATCH"
-            clarify = (
-                "I couldn’t find matching content in the KB yet. To help me narrow it down, please share:\n\n"
-                "• Module/area (e.g., Picking, Receiving, Trailer Close)\n"
-                "• Exact error message text/code (copy-paste)\n"
-                "• IDs involved (Order#, Load ID, Shipment#)\n"
-                "• Warehouse/site & environment (prod/test)\n"
-                "• When it started and how many users are impacted\n\n"
-                "Reply with these details and I’ll search again."
-            ) if not second_try else "I still don’t find a relevant KB match for this scenario even after clarification."
+            clarify_text = (
+                _build_clarifying_message()
+                if not second_try
+                else "I still don’t find a relevant KB match for this scenario even after clarification."
+            )
             return {
-                "bot_response": clarify,
+                "bot_response": clarify_text,
                 "status": "NO_KB_MATCH",
-                "context_found": False, "ask_resolved": False,
+                "context_found": False,
+                "ask_resolved": False,
                 "suggest_incident": bool(second_try),
                 "followup": ("Please reply with the above details." if not second_try else "Shall I create a ticket now?"),
-                "top_hits": [], "sources": [],
+                "top_hits": [],
+                "sources": [],
                 "debug": {"used_chunks": 0, "second_try": second_try, "best_distance": best_distance, "best_combined": best_combined},
             }
 
-        # --- Default response for non-steps
-        bot_text = context.strip()
-        status   = "OK" if exact else "PARTIAL"
+        # LLM rewrite (kept, but we still fallback cleanly)
+        enhanced_prompt = (
+            "From the provided context, output only the actionable steps/procedure relevant to the user's question. "
+            "Use ONLY the provided context; do NOT add information that is not present. "
+            + ("Return ONLY lines containing the requested action verbs. " if actions else "")
+            + "Do NOT include document names, section titles, or 'Source:' lines.\n\n"
+            f"### Context\n{context}\n\n"
+            f"### Question\n{input_data.user_message}\n\n"
+            "### Output\n"
+            "- Return numbered/bulleted steps in the same order.\n"
+            "- If context is insufficient, add: 'This may be partial based on available KB.'\n"
+        )
+        headers = {"Content-Type": "application/json"}
+        payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]}
+        try:
+            resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=25, verify=VERIFY_SSL)
+            try:
+                result = resp.json()
+            except Exception:
+                result = {}
+        except Exception:
+            resp = type("RespStub", (), {"status_code": 0})()
+            result = {}
+
+        try:
+            bot_text = (result["candidates"][0]["content"]["parts"][0]["text"] if isinstance(result, dict) else "")
+        except Exception:
+            bot_text = ""
+
+        if not bot_text.strip():
+            bot_text = context
+        bot_text = _strip_any_source_lines(bot_text).strip()
+        
+# If the intent is steps, render lines as a numbered Markdown list
+        if kb_results.get("user_intent", "neutral") == "steps":
+           raw_lines = [ln.strip() for ln in bot_text.splitlines() if ln.strip()]
+
+    # If everything is on a single line, split defensively on ". "
+           if len(raw_lines) == 1:
+              parts = [p.strip() for p in re.split(r"\.\s+(?=[A-Z0-9])", raw_lines[0]) if p.strip()]
+              raw_lines = parts if len(parts) > 1 else raw_lines
+
+    # 🔴 NEW: merge number-only lines with the next line
+        merged: list[str] = []
+        i = 0
+        while i < len(raw_lines):
+           curr = raw_lines[i]
+        # A number-only line (e.g., "1", "2", "3")
+           if re.fullmatch(r"\d+", curr) and (i + 1) < len(raw_lines):
+              nxt = raw_lines[i + 1].strip()
+            # Combine into one line: "1. <next line text>"
+              merged.append(f"{curr}. {nxt}")
+              i += 2  # skip the next line; already merged
+           else:
+               merged.append(curr)
+               i += 1
+
+    # Finally: normalize and render as Markdown numbered list
+        bot_text = _format_steps_markdown(merged)
+
+        status = "OK" if (
+            (best_combined is not None and best_combined >= gate_combined_ok)
+            or (filt_info.get('mode') == 'exact' and filt_info.get('matched_count', 0) > 0)
+        ) else "PARTIAL"
+
+        lower = bot_text.lower()
+        if ("partial" in lower) or ("may be partial" in lower) or ("closest" in lower) or ("may not fully" in lower):
+            status = "PARTIAL"
+
         return {
             "bot_response": bot_text,
             "status": status,
             "context_found": True,
             "ask_resolved": (status == "OK"),
             "suggest_incident": False,
-            "followup": ("Does this match your scenario? I can refine." if status == "PARTIAL" else None),
-            "top_hits": [], "sources": [],
+            "followup": ("Does this match your scenario? I can refine the steps." if status == "PARTIAL" else None),
+            "top_hits": [],
+            "sources": [],
             "debug": {
                 "used_chunks": len(context.split("\n\n---\n\n")) if context else 0,
-                "best_distance": best_distance, "best_combined": best_combined,
-                "filter_mode": filt_info.get("mode"), "matched_count": filt_info.get("matched_count"),
-                "user_intent": detected_intent, "actions": actions, "best_doc": best_doc,
-                "exact": exact, "high_conf": high_conf,
+                "best_distance": best_distance,
+                "best_combined": best_combined,
+                "http_status": getattr(resp, "status_code", 0),
+                "filter_mode": filt_info.get("mode"),
+                "matched_count": filt_info.get("matched_count"),
+                "user_intent": detected_intent,
+                "actions": actions,
+                "best_doc": best_doc,
             },
         }
 
@@ -619,29 +721,146 @@ async def chat_with_ai(input_data: ChatInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
-# --------------------------------------------------------
-# Incident endpoints (direct create + status + description)
-# --------------------------------------------------------
+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_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
+
 @app.post("/incident")
 async def raise_incident(input_data: IncidentInput):
     try:
         result = create_incident(input_data.short_description, input_data.description)
         if isinstance(result, dict) and not result.get("error"):
             inc_number = result.get("number", "<unknown>")
-            return {
-                "bot_response": f"✅ Incident created: {inc_number}",
-                "debug": "Incident created via ServiceNow",
-                "persist": True,
-                "show_assist_card": True,
-                "followup": "Is there anything else I can assist you with?",
-            }
+            sys_id = result.get("sys_id")
+            resolved_note = ""
+            if bool(input_data.mark_resolved) and sys_id not in ("<unknown>", None):
+                ok = _set_incident_resolved(sys_id)
+                resolved_note = " (marked Resolved)" if ok else " (could not mark Resolved; please update manually)"
+            ticket_text = f"Incident created: {inc_number}{resolved_note}"
         else:
-            err = (result or {}).get("error", "Unknown error")
+            ticket_text = "Incident created."
+        return {
+            "bot_response": f"✅ {ticket_text}",
+            "debug": "Incident created via ServiceNow",
+            "persist": True,
+            "show_assist_card": True,
+            "followup": "Is there anything else I can assist you with?",
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=safe_str(e))
+
+@app.post("/generate_ticket_desc")
+async def generate_ticket_desc_ep(input_data: TicketDescInput):
+    try:
+        prompt = (
+            f"You are helping generate ServiceNow ticket descriptions based on the issue: {input_data.issue}.\n"
+            "Please return the output strictly in JSON format with the following keys:\n"
+            "{\n"
+            ' "ShortDescription": "A concise summary of the issue (max 100 characters)",\n'
+            ' "DetailedDescription": "A detailed explanation of the issue"\n'
+            "}\n"
+            "Do not include any extra text, comments, or explanations outside the JSON."
+        )
+        headers = {"Content-Type": "application/json"}
+        payload = {"contents": [{"parts": [{"text": prompt}]}]}
+        resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=25, verify=GEMINI_GSL_VERIFY if 'GEMINI_GSL_VERIFY' in globals() else GEMINI_SSL_VERIFY)
+        try:
+            data = resp.json()
+        except Exception:
+            return {"ShortDescription": "", "DetailedDescription": "", "error": "Gemini returned non-JSON"}
+        try:
+            text = data["candidates"][0]["content"]["parts"][0]["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 {
-                "bot_response": f"⚠️ Could not create incident ({err}).",
-                "status": "PARTIAL",
-                "suggest_incident": True,
+                "ShortDescription": ticket_json.get("ShortDescription", "").strip(),
+                "DetailedDescription": ticket_json.get("DetailedDescription", "").strip(),
             }
+        except Exception:
+            return {"ShortDescription": "", "DetailedDescription": "", "error": "Invalid JSON returned"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
@@ -667,14 +886,13 @@ async def incident_status(input_data: TicketStatusInput):
         else:
             raise HTTPException(status_code=400, detail="Provide IncidentID (number) or sys_id")
         state_code = builtins.str(result.get("state", "unknown"))
-        state_map = {"1":"New","2":"In Progress","3":"On Hold","6":"Resolved","7":"Closed","8":"Canceled"}
-        state_label = state_map.get(state_code, state_code)
+        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"
-                f"**Status:** {state_label}\n"
+                f"**Ticket:** {number} \n"
+                f"**Status:** {state_label} \n"
                 f"**Issue description:** {short}"
             ).replace("\n", " \n"),
             "followup": "Is there anything else I can assist you with?",
@@ -685,16 +903,15 @@ async def incident_status(input_data: TicketStatusInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
-@app.post("/generate_ticket_desc")
-async def generate_ticket_desc_ep(input_data: TicketDescInput):
-    try:
-        # Minimal: echo structured JSON (no external LLM)
-        issue = (input_data.issue or "").strip()
-        short = issue[:100]
-        detailed = issue
-        return {
-            "ShortDescription": short,
-            "DetailedDescription": detailed,
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=safe_str(e))
+# ---- Admin endpoints (optional) ----
+@app.get("/kb/info")
+async def kb_info():
+    from services.kb_creation import get_kb_runtime_info
+    return get_kb_runtime_info()
+
+@app.post("/kb/reset")
+async def kb_reset():
+    from services.kb_creation import reset_kb
+    folder_path = os.path.join(os.getcwd(), "documents")
+    return reset_kb(folder_path)
+