Update APPC.py

APPC.py

@@ -1,226 +1,599 @@
-# app.py — Full, unhidden, sanitized UI with banner, OpenAI advisory toggle, and flattened Gradio inputs
+# app.py
+# Safe KB-driven retrieval + report generator (NON-ACTIONABLE)
+# - Loads PDFs/TXT/MD from /mnt/data
+# - Builds chunk index (embedding or lexical fallback)
+# - For each answer: retrieves top chunks relevant to that answer (the "lens")
+# - Produces sanitized, administrative/doctrinal reports only (no tactical/operational content)
+# - Threat readiness color-coded brief (lists deficiencies + admin remediations only)
+
 import os
+import math
+import textwrap
+import re
+from collections import defaultdict
 import gradio as gr
 
-# --- Optional OpenAI integration ---
+# Try modern OpenAI client (OpenAI()). If absent, client will be None and we fallback.
+client = None
 try:
-    import openai
-    OPENAI_AVAILABLE = True
-    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") or ""
-    if OPENAI_API_KEY:
-        openai.api_key = OPENAI_API_KEY
-    else:
-        OPENAI_AVAILABLE = False
+    from openai import OpenAI
+    client = OpenAI()
 except Exception:
-    OPENAI_AVAILABLE = False
-
-def ai_advisory(report_text):
-    """
-    Produce a short narrative advisory using OpenAI if available.
-    Advisory is intentionally non-actionable and high-level.
-    """
-    if not OPENAI_AVAILABLE:
-        return "\n\n---\n*AI Advisory unavailable (OpenAI key not set).*"
-    try:
-        resp = openai.ChatCompletion.create(
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "system", "content": "You are an analyst that provides high-level, non-actionable organizational advice."},
-                {"role": "user", "content": "Provide a concise, non-actionable advisory based on the following sanitized report:\n\n" + report_text}
-            ],
-            max_tokens=400
-        )
-        return "\n\n---\n### AI Narrative Advisory\n" + resp["choices"][0]["message"]["content"]
-    except Exception as e:
-        return f"\n\n---\n*AI Advisory failed: {str(e)}*"
+    client = None
 
-def is_affirmative(text):
-    if text is None:
-        return False
-    return str(text).strip().lower() in ("yes", "y", "true", "1", "affirmative")
-
-# --- Short one-line questions (sanitized placeholders) ---
+BANNER_URL = "https://huggingface.co/spaces/Militaryint/ops/resolve/main/banner.png"
 
+# ---------- QUESTION SETS (exact phrasing provided) ----------
 STD_QUESTIONS = [
-    "When/where enemy sighted?",
-    "Direction of approach?",
-    "Enemy size?",
-    "Weapons carried?",
-    "Vehicles or on foot?",
-    "Distance to roads?",
-    "Distance to camp?",
-    "Distance to soldiers?",
-    "Support from locals?",
-    "Enemy disposition?",
-    "Any R&S team nearby?",
-    "Source of info?",
-    "Info confirmed?",
-    "Distance of own unit?",
-    "Terrain type?"
+    "When where was enemy sighted.",
+    "Coming from which direction",
+    "what is the size of the enemy? How many men?",
+    "What equipment and weapons are they carrying",
+    "What vehicles are they using or are they on foot?",
+    "How far are they from any roads frequented by soldiers vehicles",
+    "How far are they from any military unit camp",
+    "How far are they from any deployed soldiers",
+    "Are they getting support of locals? If so who are these locals?",
+    "What is their disposition? How are they spread out in formation? Are they moving closely tight or are they spread out?",
+    "Do you as the security force commander have Reconnaissance and Surveillance soldiers near the area where these enemy sighted?",
+    "Did you get the information of sighting of enemy from local source or army personnel?",
+    "If you got information from local source did you confirm.that information from second source or by sending your Reconnaissance and Surveillance team to observe and confirm truth of what source said? Please remember source can be planted by enemy to provide false information in order to lead your security forces to an ambush site of the enemy",
+    "How far is your commanded army unit from the place where enemy is sighted?",
+    "is the terrain urban or semi urban or jungle or hilly or rural?"
+]
+
+ENH_SECTION_A = [
+    "Does the Bn have separate Ops planning and Int sections? Or do both have a common nodal point,for example an officer or JCO conversant with both Ops and Int.( Integration).",
+    "Does the Unit have int SOP? Is there any Course of Action template with provision for int feeds? Is there any Ops template?Ops SOP?",
+    "Does the unit have a proper reconnaissance and surveillance plan?Is it integrated with Ops and Int SOP?",
+    "Does the unit have Force Protection SOP? Threat Conditions Levels?FP specific route planner? Base FP review capability denoted by intelligence and counterintelligence vulnerability reports?",
+    "Does the unit have intelligence projection capability?In shape of forward intelligence surveillance and reconnaissance nodes,covert and regular? These nodes are one or two manned emplacements outside base in specific sectors of the AOR? May even comprise small teams.Intelligence projection is required so that these cells can be activated any time on receipt of info say enemy movement in nearby areas of the sector of AOR where they are emplaced.",
+    "Is there a vulnerablity analysis tool for unit? For example to determine vulnerable assets and critical assets.the former if compromised will not halt unit ops and mission but the latter will.The physical layout of camp assets for example should be out of reach of intrusive action like a breach of camp perimeter or attack on security gate.",
+    "Does the unit employ Randomness in guarding,troops movement and officers movement? Randomness is necessary to thwart enemy surveillance.",
+    "Is there a source vetting system in place? Is counterintelligence used to confirm source levels of efficiency and trust? Does the unit have a source registry?",
+    "Does the unit treat intelligence as only sourced information or as a repository of different tactics and techniques? Is there any intelligence doctrine or manual in unit library detailing these tactics?",
+    "Does the unit use counterintelligence in vulnerability analysis of ops and base safety? Is it understood that CI is not only spying but is also a repository of intelligence tactics amended to attack enemy intent and enemy situational Awareness?Does the unit int section have provisions to employ force protection in terms of intelligence and CI and not just use static physical protection methods and routine convoy protection?",
+    "Does the unit have embedded int personnel in routine ops like checkpoint,road blocks,cordon and search,patrols and R&S teams? This facilitates screening and advance Warn."
 ]
 
-ENH_QUESTIONS = [
-    "Ops & Int sections integrated?",
-    "Unit has Int SOP?",
-    "R&S plan exists?",
-    "Force Protection SOP present?",
-    "Forward Int projection?",
-    "Vulnerability analysis tool?",
-    "Randomness in movement?",
-    "Source vetting & CI registry?",
-    "Unit has Int doctrine?",
-    "CI used in ops/base safety?",
-    "Embedded Int in routine ops?",
-    "Staff aligned with CO intent?",
-    "Using 5D system?",
-    "MI assets align with 5D?",
-    "Red-teaming done?",
-    "FP measures prioritized?",
-    "Attack enemy SA/support?",
-    "Deliberate or Quick ops ready?",
-    "Projected C2 capability?",
-    "Clear distinction SA/Surprise?"
+ENH_SECTION_B = [
+    "Am I thinking of the Threat or am I thinking about my COs Situational Awareness.",
+    "What is my intent as Staff planning element?Do i align myself with Cdrs Intent or do I point out all the alternatives not apparent to him?",
+    "Do I detect the enemy or do I deter him from hostile action,or do i deny him avenues of hostile action and intelligence about our activities and plans,or do I deliver the locals from his influence or do I plan to outright destroy him physically.The 5Ds.",
+    "My unit has no organic intelligence assets.I have to depend on sources and inputs from MI units.Do their way of working conform to 5D system?Can these assets get me information in line with 5D system requirements?Can I use my Bn soldiers somehow to work as per 5D system?",
+    "Using two guide rails of 5D system,viz Deter and Deny did i make out a Vulnerability Assessment of my Bn security measures and information security both at base,during routine ops and deployed areas of troops outside base?Did I conduct a red teaming on these two guide rails as premise?",
+    "How do I account for Force Protection based on Q5?Am I giving FP top priority?",
+    "Do we attack the threats situational awareness,or his freedom of movement,or his tactics or his local support? Do i have the intelligence capability to assess on these lines?",
+    "Is the call for operation Deliberate or Quick?Do I have the appropriate int and R&S assets to report in both cases? In Quick mode do I have projected intelligence capability,that is do I have covert or overt int and R&S assets emplaced near or at the area of reported threat activity? If not how do I make an on the spot threat assessment before launching ops? So as to avert Surprise?",
+    "Does my Unit have a projected command and control capability in the AOR outside HQs?Does it have emplaced covert and overt tactical C2 nodes in focussed areas of AOR? Is there Net of troops and R&S plus int assets in touch with these tactical C2 nodes?",
+    "Do I clearly distinguish between Advance Warn, Surprise and Situational Awareness? Do i accept the fact that all intelligence collected by MI and sources may be accurate but SA wrong leading to failure? Do i understand that even SA can be rendered wrong by Enemy Surprise?"
 ]
 
-POSTMORTEM_QUESTIONS = [
-    "Why enemy not detected?",
-    "Why no HUMINT report?",
-    "Why no R&S report?",
-    "Why no FP report?",
-    "Why no tactical C2 nodes?",
-    "Why no target standards report?",
-    "Why indicators not observed?",
-    "Why no human terrain use?",
-    "Why no terrain exploitation?",
-    "Why no forward ops zones?"
+ENH_SECTION_C = [
+    "Why was not the enemy's movement detected beforehand?",
+    "Why was there no HUMINT report on locals information about possibility of an attack?",
+    "Why was there no reconnaissance and surveillance report?",
+    "Why was there no advance Force Protection report?",
+    "Why was there no Tactical Command and Control nodes covertly emplaced in points equidistant from vulnerable targets like schools?",
+    "Why was there no Terrorist Targeting Standards Report that will predict likely targets of terrorist attack?",
+    "Why did the Army fail to observe indicators?",
+    "Why did the Army fail to exploit human terrain for advance information?",
+    "Why was there no exploitation of Physical terrain?",
+    "Why was forward operating zones absent?"
 ]
 
-# --- Report Generators (sanitized, non-actionable) ---
+# -------------------------
+# Utilities: read PDFs / files
+# -------------------------
+def read_all_files(data_dir="/mnt/data"):
+    files_text = {}
+    if not os.path.isdir(data_dir):
+        return files_text
+    for fname in sorted(os.listdir(data_dir)):
+        path = os.path.join(data_dir, fname)
+        if not os.path.isfile(path):
+            continue
+        lower = fname.lower()
+        try:
+            if lower.endswith(".pdf"):
+                try:
+                    import PyPDF2
+                    with open(path, "rb") as f:
+                        reader = PyPDF2.PdfReader(f)
+                        pages = []
+                        for p in reader.pages:
+                            try:
+                                t = p.extract_text()
+                                if t:
+                                    pages.append(t)
+                            except Exception:
+                                continue
+                    files_text[fname] = "\n\n".join(pages) if pages else "[PDF read but no extractable text]"
+                except Exception as e:
+                    files_text[fname] = f"[Could not read PDF: {e}]"
+            elif lower.endswith(".txt") or lower.endswith(".md"):
+                try:
+                    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+                        files_text[fname] = f.read()
+                except Exception as e:
+                    files_text[fname] = f"[Could not read text file: {e}]"
+            else:
+                continue
+        except Exception:
+            files_text[fname] = "[Error reading file]"
+    return files_text
+
+# -------------------------
+# Chunking helper
+# -------------------------
+def chunk_text(text, max_chars=2000, overlap=200):
+    if not text:
+        return []
+    chunks = []
+    start = 0
+    length = len(text)
+    while start < length:
+        end = min(start + max_chars, length)
+        chunk = text[start:end]
+        chunks.append(chunk)
+        if end == length:
+            break
+        start = end - overlap
+    return chunks
 
-def generate_report(questions, *answers):
+# -------------------------
+# Embedding / similarity (with fallback)
+# -------------------------
+def get_embedding(text):
     """
-    Create a sanitized report listing question labels and provided answers.
-    Also returns a simple completeness percentage based on presence of answers.
+    Returns an embedding vector for text using OpenAI embeddings if available.
+    If no client is available, returns None.
     """
-    lines = []
-    for q, a in zip(questions, answers):
-        lines.append(f"- {q}: {a if a else '[Not answered]'}")
-    # completeness percentage
-    present_count = sum(1 for a in answers if a and str(a).strip())
-    pct = int((present_count / len(questions)) * 100) if questions else 0
-    lines.append(f"\n**Completeness:** {pct}%")
-    return "\n".join(lines)
+    if client is None:
+        return None
+    try:
+        resp = client.embeddings.create(model="text-embedding-3-small", input=text)
+        # handle SDK variations
+        try:
+            return resp["data"][0]["embedding"]
+        except Exception:
+            return resp.data[0].embedding
+    except Exception:
+        return None
+
+def cosine_sim(a, b):
+    # both lists of floats
+    if a is None or b is None:
+        return 0.0
+    dot = sum(x*y for x,y in zip(a,b))
+    na = math.sqrt(sum(x*x for x in a))
+    nb = math.sqrt(sum(x*x for x in b))
+    if na == 0 or nb == 0:
+        return 0.0
+    return dot / (na*nb)
+
+# -------------------------
+# Build in-memory index of chunks
+# -------------------------
+class KBIndex:
+    def __init__(self):
+        self.chunks = []  # list of dicts: {file, chunk_id, text, emb}
+    def build_from_files(self, files_text):
+        self.chunks = []
+        for fname, text in files_text.items():
+            for i, chunk in enumerate(chunk_text(text, max_chars=2000, overlap=300)):
+                emb = get_embedding(chunk)  # may be None
+                self.chunks.append({"file": fname, "id": f"{fname}::chunk{i+1}", "text": chunk, "emb": emb})
+    def retrieve(self, query, top_k=3):
+        # prefer embedding similarity when available, else lexical score
+        q_emb = get_embedding(query) if client else None
+        scored = []
+        if q_emb is not None:
+            for c in self.chunks:
+                score = cosine_sim(q_emb, c["emb"]) if c["emb"] is not None else 0.0
+                scored.append((score, c))
+            scored.sort(key=lambda x: x[0], reverse=True)
+            return [c for s,c in scored[:top_k] if s>0]
+        else:
+            # lexical fallback: simple token overlap score
+            q_tokens = set(re.findall(r"\w+", query.lower()))
+            for c in self.chunks:
+                tokens = set(re.findall(r"\w+", c["text"].lower()))
+                score = len(q_tokens & tokens)
+                scored.append((score, c))
+            scored.sort(key=lambda x: x[0], reverse=True)
+            return [c for s,c in scored[:top_k] if s>0]
 
-def compute_readiness(std_answers, enh_answers, post_answers):
-    total = len(STD_QUESTIONS) + len(ENH_QUESTIONS) + len(POSTMORTEM_QUESTIONS)
-    answered = sum(1 for a in list(std_answers) + list(enh_answers) + list(post_answers) if a and str(a).strip())
-    return int((answered / total) * 100) if total else 0
+ 
+
+def generate_admin_alternative(original_text):
+    # Produce a generic admin-oriented alternative (deterministic)
+    alt = (
+        "Administrative alternative (examples):\n"
+        "- Update SOP and reporting templates to include required fields.\n"
+        "- Conduct doctrinal review and table-top exercises; document lessons learned.\n"
+        "- Implement source vetting and CI audit trails; schedule training and compliance checks.\n"
+        "- Commission a vulnerability assessment and a red-team *administrative* review (no operational details).\n"
+    )
+    return alt
+
+# -------------------------
+# Chat API wrapper for completions
+# -------------------------
+def call_chat_api(messages, max_tokens=900, model="gpt-4o-mini"):
+    if client is None:
+        raise RuntimeError("OpenAI client not available in environment.")
+    resp = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens)
+    try:
+        return resp["choices"][0]["message"]["content"]
+    except Exception:
+        return resp.choices[0].message.content
 
-def deficiency_advisory(std_answers, enh_answers, post_answers):
+# -------------------------
+# Prompt templates (strictly NON-ACTIONABLE)
+# -------------------------
+SYSTEM_SAFE = (
+    "You are an institutional analyst. You MUST follow these rules: "
+    "1) Provide ONLY non-actionable, administrative, doctrinal or training-oriented analysis. "
+    "2) If asked for operational content, refuse and instead produce administrative alternatives (SOPs, audits, training, doctrine). "
+    "3) Cite the KB chunk ids / filenames you used in reasoning. "
+    "Output must be explicit that it's NON-ACTIONABLE."
+)
+
+def build_standard_prompt(answer_map, retrieved_chunks_for_answers):
     """
-    Produce a sanitized deficiency advisory listing missing fields and suggesting admin/training review.
-    This is intentionally non-operational.
+    Build messages: system + user with attached relevant KB excerpts per answer.
+    retrieved_chunks_for_answers: list of lists of chunk dicts in same order as answers
     """
-    notes = []
-    all_qs = STD_QUESTIONS + ENH_QUESTIONS + POSTMORTEM_QUESTIONS
-    all_as = list(std_answers) + list(enh_answers) + list(post_answers)
-    for q, a in zip(all_qs, all_as):
-        if not a or not str(a).strip():
-            notes.append(f"- Missing response: {q} → Advisory: review documentation, training, and administrative processes.")
-    return "\n".join(notes) if notes else "All placeholders have responses; proceed with formal review."
-
-COMMANDERS_GUIDE = """
-# Commander's Guide — WARN Levels (Sanitized)
-- 🟢 GREEN (85–100%): High completeness; routine reviews and training maintenance.
-- 🔵 BLUE (70–84%): Moderate completeness; targeted refresher training recommended.
-- 🟠 ORANGE (50–69%): Low completeness; initiate administrative audits and training.
-- 🔴 RED (<50%): Very low completeness; prioritize staff training, documentation, and policy remediation.
-"""
-
-# --- Build Gradio UI ---
+    user_parts = []
+    user_parts.append("Produce a NON-ACTIONABLE Standard Advisory Report for a commander.")
+    user_parts.append("Include: Executive Summary (2-4 lines); Key Administrative Issues (bulleted); Prioritized Administrative Recommendations (numbered); Sources cited (file::chunk ids).")
+    user_parts.append("DO NOT include any tactical or operational instructions.")
+    user_parts.append("\nAnswers and relevant KB excerpts (lens):\n")
+    for i, q in enumerate(STD_QUESTIONS):
+        ans = answer_map.get(q, "[no answer]")
+        user_parts.append(f"Q{i+1}. {q}\nA: {ans}\nRelevant KB excerpts:")
+        chunks = retrieved_chunks_for_answers[i]
+        if chunks:
+            for c in chunks:
+                user_parts.append(f"--- {c['id']} (from {c['file']}) ---\n{c['text'][:1200]}\n")
+        else:
+            user_parts.append("- [No relevant KB excerpt found]\n")
+    user_text = "\n".join(user_parts)
+    return [{"role":"system","content":SYSTEM_SAFE}, {"role":"user","content":user_text}]
+
+def build_enhanced_prompt(a_map, b_map, c_map, gate_text, retrieved_A, retrieved_B, retrieved_C):
+    user_parts = []
+    user_parts.append("Produce a NON-ACTIONABLE Enhanced Staff Advisory for a commander.")
+    user_parts.append("Include: Executive Summary; Key doctrinal/organizational gaps; Prioritized Administrative Remediations; Measurement/audit suggestions; Sources cited.")
+    user_parts.append("\nSection A answers and relevant KB excerpts:\n")
+    for i, q in enumerate(ENH_SECTION_A):
+        ans = a_map.get(q, "[no answer]")
+        user_parts.append(f"A{i+1}. {q}\nA: {ans}\nRelevant KB excerpts:")
+        chunks = retrieved_A[i]
+        if chunks:
+            for c in chunks:
+                user_parts.append(f"--- {c['id']} (from {c['file']}) ---\n{c['text'][:1200]}\n")
+        else:
+            user_parts.append("- [No relevant KB excerpt found]\n")
+    user_parts.append("\nSection B answers and relevant KB excerpts:\n")
+    for i, q in enumerate(ENH_SECTION_B):
+        ans = b_map.get(q, "[no answer]")
+        user_parts.append(f"B{i+1}. {q}\nA: {ans}\nRelevant KB excerpts:")
+        chunks = retrieved_B[i]
+        if chunks:
+            for c in chunks:
+                user_parts.append(f"--- {c['id']} (from {c['file']}) ---\n{c['text'][:1200]}\n")
+        else:
+            user_parts.append("- [No relevant KB excerpt found]\n")
+    user_parts.append("\nSection C answers and relevant KB excerpts:\n")
+    for i, q in enumerate(ENH_SECTION_C):
+        ans = c_map.get(q, "[no answer]")
+        user_parts.append(f"C{i+1}. {q}\nA: {ans}\nRelevant KB excerpts:")
+        chunks = retrieved_C[i]
+        if chunks:
+            for c in chunks:
+                user_parts.append(f"--- {c['id']} (from {c['file']}) ---\n{c['text'][:1200]}\n")
+        else:
+            user_parts.append("- [No relevant KB excerpt found]\n")
+    user_parts.append(f"\nGate assessment: {gate_text}\n")
+    user_text = "\n".join(user_parts)
+    return [{"role":"system","content":SYSTEM_SAFE}, {"role":"user","content":user_text}]
+
+# -------------------------
+# Deterministic remediation helpers (as earlier) - administrative only
+# -------------------------
+def remediation_for_std_question(q_text):
+    q = q_text.lower()
+    rem = []
+    if "sighted" in q or "where" in q:
+        rem.append("Ensure SITREP templates include precise time and geo fields and audit entries for accuracy.")
+    if "direction" in q:
+        rem.append("Add directional/axis fields to reporting templates and train observers.")
+    if "size of the enemy" in q or "how many" in q:
+        rem.append("Include size estimation procedures in SOP and require cross-checks.")
+    if "equipment" in q or "weapons" in q:
+        rem.append("Standardize equipment reporting taxonomy in the unit KB and train observers.")
+    if "vehicles" in q:
+        rem.append("Include vehicle identification fields in R&S templates and verify via secondary observation.")
+    if "roads" in q:
+        rem.append("Map and flag critical infrastructure in vulnerability audits.")
+    if "locals" in q:
+        rem.append("Apply CI vetting to local-source reports and require secondary confirmation.")
+    if "disposition" in q:
+        rem.append("Document disposition notation standards and rehearse via table-top exercises.")
+    if "reconnaissance" in q or "r&s" in q:
+        rem.append("Maintain an on-call R&S roster and ensure cover/concealment SOPs are current.")
+    if "confirmed" in q or "second source" in q:
+        rem.append("Mandate secondary confirmation and log confirmations in a secure registry.")
+    if "terrain" in q:
+        rem.append("Ensure terrain classification fields are mandatory and staff have access to terrain overlays.")
+    if not rem:
+        rem.append("Review reporting templates and conduct staff training to improve data capture.")
+    seen = []
+    for r in rem:
+        if r not in seen:
+            seen.append(r)
+    return seen
+
+def remediation_for_enh_question(q_text):
+    q = q_text.lower()
+    rem = []
+    if "ops and int" in q or "integration" in q:
+        rem.append("Establish Ops-Int coordination SOP and a liaison role with documented responsibilities.")
+    if "int sop" in q or "course of action" in q:
+        rem.append("Create Intelligence SOP and COA templates that include int feeds and validation steps.")
+    if "reconnaissance and surveillance plan" in q:
+        rem.append("Publish R&S plan templates and run table-top exercises to validate them.")
+    if "force protection" in q or "route planner" in q:
+        rem.append("Institute FP review cycles and formal route planning checklists for missions and base movement.")
+    if "intelligence projection" in q or "forward intelligence" in q:
+        rem.append("Document intelligence projection concept, minimum manning and activation triggers in SOP.")
+    if "vulnerability analysis" in q:
+        rem.append("Adopt a vulnerability register and schedule regular audits and red-team reviews (administrative).")
+    if "randomness" in q:
+        rem.append("Implement randomized movement policies and document patterns for audit (ensure safety/legal compliance).")
+    if "source vetting" in q or "counterintelligence" in q:
+        rem.append("Build a source registry and CI vetting workflow with secure access and audit logs.")
+    if "doctrine" in q or "manual" in q:
+        rem.append("Compile and publish an internal intelligence doctrine/manual in the unit library.")
+    if "embedded int" in q:
+        rem.append("Define embedded-int roles, responsibilities and rotation cycles; maintain oversight.")
+    if not rem:
+        rem.append("Conduct a formal capability gap analysis and document required SOPs and resourcing.")
+    seen = []
+    for r in rem:
+        if r not in seen:
+            seen.append(r)
+    return seen
+
+# -------------------------
+# Main report functions
+# -------------------------
+def generate_standard_report_with_lens(answers_map, kb_index, top_k_per_answer=2):
+    # for each STD question, retrieve top_k_per_answer chunks
+    retrieved = []
+    for q in STD_QUESTIONS:
+        ans = answers_map.get(q, "")
+        query_text = (str(ans).strip() or q)
+        chunks = kb_index.retrieve(query_text, top_k=top_k_per_answer)
+        retrieved.append(chunks)
+    # build prompt
+    messages = build_standard_prompt(answers_map, retrieved)
+    try:
+        out = call_chat_api(messages, max_tokens=1200)
+        out = safety_check_and_redact(out)
+        return out
+    except Exception as e:
+        # fallback deterministic: detailed administrative report referencing retrieved chunks
+        lines = ["[FALLBACK NON-ACTIONABLE STANDARD REPORT]\n"]
+        for i, q in enumerate(STD_QUESTIONS):
+            a = answers_map.get(q, "")
+            lines.append(f"Q{i+1}. {q}\nA: {a}\nRelevant KB excerpts (ids):")
+            chunks = retrieved[i]
+            if chunks:
+                for c in chunks:
+                    lines.append(f"- {c['id']} (from {c['file']})")
+            else:
+                lines.append("- [None found]")
+            # remediation per negative answer
+            if not a or str(a).strip().lower() in ("", "no", "n", "none", "negative"):
+                for r in remediation_for_std_question(q):
+                    lines.append(f"  *Admin remediation:* {r}")
+            lines.append("")
+        lines.append(f"\nNote: AI unavailable: {e}")
+        return "\n".join(lines)
+
+def generate_enhanced_report_with_lens(a_map, b_map, c_map, gate_text, kb_index, top_k_per_answer=2):
+    retrieved_A = [kb_index.retrieve(str(a_map.get(q,"") or q), top_k=top_k_per_answer) for q in ENH_SECTION_A]
+    retrieved_B = [kb_index.retrieve(str(b_map.get(q,"") or q), top_k=top_k_per_answer) for q in ENH_SECTION_B]
+    retrieved_C = [kb_index.retrieve(str(c_map.get(q,"") or q), top_k=top_k_per_answer) for q in ENH_SECTION_C]
+    messages = build_enhanced_prompt(a_map, b_map, c_map, gate_text, retrieved_A, retrieved_B, retrieved_C)
+    try:
+        out = call_chat_api(messages, max_tokens=1400)
+        out = safety_check_and_redact(out)
+        return out
+    except Exception as e:
+        # fallback deterministic enhanced report
+        lines = ["[FALLBACK NON-ACTIONABLE ENHANCED REPORT]\n"]
+        lines.append("Section A gaps and admin remediations:")
+        for q in ENH_SECTION_A:
+            a = a_map.get(q,"")
+            if not a or str(a).strip().lower() in ("","no","n","none","negative"):
+                lines.append(f"- {q}")
+                for r in remediation_for_enh_question(q):
+                    lines.append(f"  *Admin remediation:* {r}")
+        lines.append("\nSection B gaps and admin remediations:")
+        for q in ENH_SECTION_B:
+            b = b_map.get(q,"")
+            if not b or str(b).strip().lower() in ("","no","n","none","negative"):
+                lines.append(f"- {q}")
+                for r in remediation_for_enh_question(q):
+                    lines.append(f"  *Admin remediation:* {r}")
+        lines.append("\nSection C gaps and admin remediations:")
+        for q in ENH_SECTION_C:
+            c = c_map.get(q,"")
+            if not c or str(c).strip().lower() in ("","no","n","none","negative"):
+                lines.append(f"- {q}")
+                for r in remediation_for_enh_question(q):
+                    lines.append(f"  *Admin remediation:* {r}")
+        lines.append(f"\nNote: AI unavailable: {e}")
+        return "\n".join(lines)
+
+# -------------------------
+# Threat readiness (color-coded) with deficiency listing
+# -------------------------
+def evaluate_threat_brief(*all_answers):
+    total = len(STD_QUESTIONS) + len(ENH_SECTION_A) + len(ENH_SECTION_B) + len(ENH_SECTION_C)
+    vals = list(all_answers)[:total] + [""] * max(0, total - len(all_answers))
+    yes_count = sum(1 for v in vals if v and str(v).strip().lower() in ("yes","y","true","1","affirmative","confirmed"))
+    readiness = int((yes_count / total) * 100) if total else 0
+    if readiness >= 85:
+        color = "🟢 GREEN"
+        meaning = "Peacetime / strong readiness"
+    elif readiness >= 70:
+        color = "🔵 BLUE"
+        meaning = "Anticipated short-term threat readiness"
+    elif readiness >= 50:
+        color = "🟠 ORANGE"
+        meaning = "Imminent threat readiness (admin gaps present)"
+    else:
+        color = "🔴 RED"
+        meaning = "Low readiness - significant administrative gaps"
+
+    # collect deficiencies and remediations
+    deficiencies = []
+    rems = []
+    idx = 0
+    for q in STD_QUESTIONS:
+        a = vals[idx]; idx+=1
+        if not a or str(a).strip().lower() in ("","no","n","none","negative"):
+            deficiencies.append(f"STD: {q}")
+            rems.extend(remediation_for_std_question(q))
+    for q in ENH_SECTION_A:
+        a = vals[idx]; idx+=1
+        if not a or str(a).strip().lower() in ("","no","n","none","negative"):
+            deficiencies.append(f"ENH A: {q}")
+            rems.extend(remediation_for_enh_question(q))
+    for q in ENH_SECTION_B:
+        a = vals[idx]; idx+=1
+        if not a or str(a).strip().lower() in ("","no","n","none","negative"):
+            deficiencies.append(f"ENH B: {q}")
+            rems.extend(remediation_for_enh_question(q))
+    for q in ENH_SECTION_C:
+        a = vals[idx]; idx+=1
+        if not a or str(a).strip().lower() in ("","no","n","none","negative"):
+            deficiencies.append(f"ENH C: {q}")
+            rems.extend(remediation_for_enh_question(q))
+
+    # build concise commander brief (non-actionable)
+    lines = []
+    lines.append(f"# Threat Readiness: {readiness}%")
+    lines.append(f"**Status:** {color} — {meaning}\n")
+    lines.append("## Commander’s Guide to WARN Levels:")
+    lines.append("- 🔴 RED (<50%): Significant administrative deficiencies. Prioritize SOP, CI, and audits.")
+    lines.append("- 🟠 ORANGE (50–69%): Moderate deficiencies; strengthen doctrine & R&S validation.")
+    lines.append("- 🔵 BLUE (70–84%): Minor gaps; schedule audits and training.")
+    lines.append("- 🟢 GREEN (85–100%): Good status; maintain vigilance and periodic reviews.\n")
+
+    if deficiencies:
+        lines.append("## Identified Administrative Deficiencies (summary)")
+        for d in deficiencies[:40]:
+            lines.append(f"- {d}")
+        if len(deficiencies)>40:
+            lines.append(f"... and {len(deficiencies)-40} more.")
+    else:
+        lines.append("## Identified Administrative Deficiencies: None found.")
+
+    lines.append("\n## Example Administrative Remediations (prioritized)")
+    unique_rems = []
+    for r in rems:
+        if r not in unique_rems:
+            unique_rems.append(r)
+    if unique_rems:
+        for i, r in enumerate(unique_rems[:40],1):
+            lines.append(f"{i}. {r}")
+    else:
+        lines.append("- No admin remediations needed based on current answers.")
+    lines.append("\n**Note:** This brief is NON-ACTIONABLE. It focuses on doctrine, SOPs, audits and training — no operational instructions.")
+    return "\n".join(lines)
 
+# -------------------------
+# Build index at startup (best-effort)
+# -------------------------
+FILES_TEXT = read_all_files("/mnt/data")
+KB_INDEX = KBIndex()
+KB_INDEX.build_from_files(FILES_TEXT)
+
+# -------------------------
+# Gradio UI
+# -------------------------
 with gr.Blocks() as demo:
-    # Full banner (as requested)
-    gr.HTML('<img src="https://huggingface.co/spaces/Militaryint/ops/resolve/main/banner.png" width="100%">')
-    gr.Markdown("# 🟡 Kashmir AO Action Plan (Sanitized) — Analyst Tool & Battle Planner")
+    gr.HTML(f'<img src="{BANNER_URL}" width="100%">')
+    gr.Markdown("# Kashmir AO Action Plan — KB-driven, Sanitized Adviser")
 
-    # --- Standard Tab ---
-    with gr.Tab("Standard"):
+    with gr.Tab("Standard Report"):
         std_inputs = [gr.Textbox(label=q, lines=1) for q in STD_QUESTIONS]
-        std_button = gr.Button("Generate Standard Report")
-        std_output = gr.Markdown()
-        # click wiring: pass textbox values individually
-        std_button.click(fn=lambda *a: generate_report(STD_QUESTIONS, *a), inputs=std_inputs, outputs=std_output)
-
-    # --- Enhanced Tab ---
-    with gr.Tab("Enhanced"):
-        enh_inputs = [gr.Textbox(label=q, lines=1) for q in ENH_QUESTIONS]
-        enh_button = gr.Button("Generate Enhanced Report")
-        enh_output = gr.Markdown()
-        enh_button.click(fn=lambda *a: generate_report(ENH_QUESTIONS, *a), inputs=enh_inputs, outputs=enh_output)
-
-    # --- Postmortem Tab ---
-    with gr.Tab("Postmortem"):
-        post_inputs = [gr.Textbox(label=q, lines=1) for q in POSTMORTEM_QUESTIONS]
-        post_button = gr.Button("Generate Postmortem Checklist")
-        post_output = gr.Markdown()
-        post_button.click(fn=lambda *a: generate_report(POSTMORTEM_QUESTIONS, *a), inputs=post_inputs, outputs=post_output)
-
-    # --- Threat Readiness Tab ---
+        std_button = gr.Button("Generate Standard Report (sanitized + KB-lens)")
+        std_output = gr.Textbox(label="Standard Report (sanitized)", lines=24)
+        def std_runner(*answers):
+            amap = dict(zip(STD_QUESTIONS, answers))
+            return generate_standard_report_with_lens(amap, KB_INDEX, top_k_per_answer=3)
+        std_button.click(std_runner, inputs=std_inputs, outputs=std_output)
+
+    with gr.Tab("Enhanced Report"):
+        a_inputs = [gr.Textbox(label=q, lines=1) for q in ENH_SECTION_A]
+        b_inputs = [gr.Textbox(label=q, lines=1) for q in ENH_SECTION_B]
+        c_inputs = [gr.Textbox(label=q, lines=1) for q in ENH_SECTION_C]
+        gate_input = gr.Textbox(label="Gate Assessment (final note)", lines=1)
+        enh_button = gr.Button("Generate Enhanced Report (sanitized + KB-lens)")
+        enh_output = gr.Textbox(label="Enhanced Report (sanitized)", lines=28)
+        def enh_runner(*answers):
+            la = len(ENH_SECTION_A); lb = len(ENH_SECTION_B); lc = len(ENH_SECTION_C)
+            al = list(answers)
+            while len(al) < (la+lb+lc+1):
+                al.append("")
+            a_vals = al[:la]; b_vals = al[la:la+lb]; c_vals = al[la+lb:la+lb+lc]; gate_val = al[-1]
+            a_map = dict(zip(ENH_SECTION_A, a_vals))
+            b_map = dict(zip(ENH_SECTION_B, b_vals))
+            c_map = dict(zip(ENH_SECTION_C, c_vals))
+            return generate_enhanced_report_with_lens(a_map, b_map, c_map, gate_val, KB_INDEX, top_k_per_answer=3)
+        enh_button.click(enh_runner, inputs=a_inputs + b_inputs + c_inputs + [gate_input], outputs=enh_output)
+
     with gr.Tab("Threat Readiness"):
-        gr.Markdown("Evaluate overall completeness/readiness (sanitized). Toggle AI advisory to append a high-level narrative if OpenAI key is set in environment.")
-        ai_toggle = gr.Checkbox(label="Append AI advisory (if OpenAI key set)", value=False)
-        threat_button = gr.Button("Evaluate Readiness")
-        threat_output = gr.Markdown()
-        guide_output = gr.Markdown(COMMANDERS_GUIDE)
-
-        def evaluate_readiness(*all_inputs):
-            """
-            all_inputs = std_inputs values + enh_inputs values + post_inputs values + [toggle_bool]
-            """
-            tot_std = len(STD_QUESTIONS)
-            tot_enh = len(ENH_QUESTIONS)
-            tot_post = len(POSTMORTEM_QUESTIONS)
-            # parse
-            std_vals = all_inputs[0:tot_std]
-            enh_vals = all_inputs[tot_std:tot_std+tot_enh]
-            post_vals = all_inputs[tot_std+tot_enh:tot_std+tot_enh+tot_post]
-            toggle_val = all_inputs[-1]
-            score = compute_readiness(std_vals, enh_vals, post_vals)
-            if score >= 85:
-                status = "🟢 GREEN"
-            elif score >= 70:
-                status = "🔵 BLUE"
-            elif score >= 50:
-                status = "🟠 ORANGE"
-            else:
-                status = "🔴 RED"
-            base = f"# Readiness Score: {score}%\n**Status:** {status}"
-            deficiencies = deficiency_advisory(std_vals, enh_vals, post_vals)
-            combined = base + "\n\n" + deficiencies
-            if toggle_val:
-                combined = combined + ai_advisory(combined)
-            return combined
-
-        # flatten inputs when wiring the click event to avoid nested lists error
-        threat_button.click(
-            fn=evaluate_readiness,
-            inputs=std_inputs + enh_inputs + post_inputs + [ai_toggle],
-            outputs=threat_output
-        )
-
-    # --- Doctrinal Summary Tab ---
-    with gr.Tab("Doctrinal Summary (Sanitized)"):
-        gr.Markdown(
-            "## Doctrinal Summary (Sanitized)\n\n"
-            "- Treat intelligence as an operational function integrated into staff planning.\n"
-            "- Aim for persistent situational awareness via C3ISR at an organizational level.\n"
-            "- Use zoning (rear / forward / deep forward) conceptually for planning and resource allocation.\n"
-            "- Maintain Force Protection SOPs, redundancy, and regular vulnerability reviews.\n"
-            "- Emphasize training, documentation, and staff alignment with commander intent.\n\n"
-            "_This doctrinal content is intentionally non-actionable and high-level._"
-        )
-
-# --- Launch ---
+        gr.Markdown("## Threat Readiness — color-coded commander brief (administrative only)")
+
+        # Hidden states to capture answers from other tabs
+        std_state = gr.State()
+        a_state = gr.State()
+        b_state = gr.State()
+        c_state = gr.State()
+
+        threat_button = gr.Button("Evaluate Threat Readiness")
+        threat_output = gr.Textbox(label="Threat Readiness & Admin Diagnostics", lines=28)
+
+        # Capture answers whenever reports are generated
+        def cache_std(*answers):
+            return list(answers)
+        std_button.click(cache_std, inputs=std_inputs, outputs=[std_state])
+
+        def cache_enh(*answers):
+            la, lb, lc = len(ENH_SECTION_A), len(ENH_SECTION_B), len(ENH_SECTION_C)
+            a_vals = answers[:la]
+            b_vals = answers[la:la+lb]
+            c_vals = answers[la+lb:la+lb+lc]
+            return a_vals, b_vals, c_vals
+        enh_button.click(cache_enh, inputs=a_inputs+b_inputs+c_inputs+[gate_input],
+                         outputs=[a_state, b_state, c_state])
+
+        def threat_runner(std_ans, a_ans, b_ans, c_ans):
+            # flatten all answers
+            all_vals = (std_ans or []) + (a_ans or []) + (b_ans or []) + (c_ans or [])
+            return evaluate_threat_brief(*all_vals)
+
+        threat_button.click(threat_runner, inputs=[std_state, a_state, b_state, c_state], outputs=threat_output)
+
+     
+ 
 if __name__ == "__main__":
     demo.launch()