Update app.py

app.py

@@ -1,116 +1,53 @@
 # app.py
-# Kashmir AO Action Plan for Inf — Enhanced KB-driven advisory app (NON-ACTIONABLE)
-# Rebuilt from your uploaded app (app (46).py) and today's requested enhancements.
 
-import os
-import math
-import re
+import os, re
 import gradio as gr
+from openai import OpenAI
 
-# Try to import modern OpenAI client (recommended).
-client = None
-try:
-    from openai import OpenAI
-    # If OPENAI_API_KEY is set in environment, the OpenAI client will pick it up (or pass explicitly).
-    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-except Exception:
-    client = None
-
-# Banner (as provided)
+# -------------------------
+# Banner URL
+# -------------------------
 BANNER_URL = "https://huggingface.co/spaces/Militaryint/ops/resolve/main/banner.png"
 
 # -------------------------
-# QUESTIONS (exact phrasing you requested)
+# Safety Block
 # -------------------------
-STD_QUESTIONS = [
-    "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?"
-]
+SYSTEM_SAFE = """
+You are a military analyst assistant. 
+All outputs must remain ACTIONABLE, and advisory tactical-only. 
+"""
 
-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."
-]
+# -------------------------
+# OpenAI Client
+# -------------------------
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
-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?"
-]
+# -------------------------
+# Knowledge Base
+# -------------------------
+from pathlib import Path
+from PyPDF2 import PdfReader
 
-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?"
-]
+def read_all_files(folder):
+    files_text = {}
+    p = Path(folder)
+    if not p.exists():
+        print(f"[KB] folder {folder} missing")
+        return files_text
+    for f in p.glob("*.pdf"):
+        try:
+            reader = PdfReader(str(f))
+            txt = "\n".join(page.extract_text() or "" for page in reader.pages)
+            files_text[f.name] = txt
+        except Exception as e:
+            print("[KB] error reading", f, e)
+    return files_text
+
+FILES_TEXT = read_all_files("knowledge_base")
 
 # -------------------------
-# Logic categories → PDF lists (you approved this mapping)
+# Priority PDFs
 # -------------------------
-LOGIC_PDFS = {
-    "enemy_detect_information": [
-        "Detect.pdf",
-        "ATTN LAW ENFORCEMENT HOW TO AVERT SURPRISE ATTACK BY CRIMINAL OR ENEMY.pdf"
-    ],
-    "course_of_action_information": [
-        "Operational Course of Action Using the Kashmir Military Algorithm.pdf",
-        "Ops_Framework.pdf",
-        "Ops_Questionnaire.pdf"
-    ],
-    "reconnaissance_surveillance": [
-        "Staff_Officer_Playbook_5D.pdf",
-        "INT_SOP_CONTROL_logic.pdf",
-        "SOP INT SECTION.pdf"
-    ],
-    "cognitive_and_intelligence": [
-        "5D_Crime_Analysis.pdf",
-        "5D_Cognitive_Warfare_Flow.pdf",
-        "The intelligence foundation of operations.pdf",
-        "UPLOAD TO CHAT.pdf"
-    ],
-    "other": [
-        "intel_investigation_rewrite (1).pdf",
-        "drugs_incoming_assessment_and_mitigations.pdf"
-    ]
-}
-
-# Priority PDFs (highest priority when retrieving)
 PRIORITY_PDFS = [
     "Operational Course of Action Using the Kashmir Military Algorithm.pdf",
     "UPLOAD TO CHAT.pdf",
@@ -119,801 +56,248 @@ PRIORITY_PDFS = [
 ]
 
 # -------------------------
-# File reading & chunking (larger chunks for richer context)
+# PARA SF Priority PDFs
 # -------------------------
-def read_all_files(paths):
-    """
-    Read PDFs and text files from the provided list of folders.
-    Returns dict: {filename: text}
-    """
-    files_text = {}
-    for d in paths:
-        if not os.path.isdir(d):
-            continue
-        for fname in sorted(os.listdir(d)):
-            path = os.path.join(d, 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"):
-                    with open(path, "r", encoding="utf-8", errors="ignore") as f:
-                        files_text[fname] = f.read()
-            except Exception as e:
-                files_text[fname] = f"[Error reading file: {e}]"
-    return files_text
-
-def chunk_text(text, max_chars=4000, overlap=400):
-    if not text:
-        return []
-    chunks = []
-    start = 0
-    L = len(text)
-    while start < L:
-        end = min(start + max_chars, L)
-        chunks.append(text[start:end])
-        if end == L:
-            break
-        start = end - overlap
-    return chunks
+SF_PRIORITY_PDFS = [
+    "Operational Course of Action Using the Kashmir Military Algorithm.pdf",
+    "UPLOAD TO CHAT.pdf",
+    "5D_Crime_Analysis.pdf",
+    "INT_SOP_CONTROL_logic.pdf",
+    "Staff_Officer_Playbook_5D.pdf"
+]
 
 # -------------------------
-# Embeddings & retrieval helpers
+# KB Index (naive)
 # -------------------------
-def get_embedding(text):
-    if client is None:
-        return None
-    try:
-        resp = client.embeddings.create(model="text-embedding-3-small", input=text)
-        try:
-            return resp["data"][0]["embedding"]
-        except Exception:
-            return resp.data[0].embedding
-    except Exception:
-        return None
-
-def cosine_sim(a, b):
-    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)
-
 class KBIndex:
     def __init__(self):
-        self.chunks = []  # dicts: {file, id, text, emb}
+        self.docs = {}
+
     def build_from_files(self, files_text):
-        self.chunks = []
-        for fname, text in files_text.items():
-            for i, chunk in enumerate(chunk_text(text)):
-                emb = get_embedding(chunk)
-                self.chunks.append({"file": fname, "id": f"{fname}::chunk{i+1}", "text": chunk, "emb": emb})
-    def retrieve(self, query, top_k=3, prefer_files=None):
-        """
-        Retrieve top_k chunks for query.
-        If prefer_files list provided, prioritize chunks from those filenames first.
-        """
-        q_emb = get_embedding(query) if client else None
-        scored = []
-        # scoring
-        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)
-        else:
-            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)
-
-        # If prefer_files provided, move those up
-        if prefer_files:
-            prioritized = [c for s,c in scored if c["file"] in prefer_files]
-            others = [c for s,c in scored if c["file"] not in prefer_files]
-            ordered = prioritized + others
-            top = ordered[:top_k]
-        else:
-            top = [c for s,c in scored[:top_k]]
-
-        # fallback: if no results, return first top_k chunks available
-        if not top:
-            top = self.chunks[:min(top_k, max(1, len(self.chunks)))]
-        return top
+        self.docs = files_text
 
-# -------------------------
-# Load KB files (priority path knowledge_base)
-# -------------------------
-KB_PATHS = ["knowledge_base"]
-FILES_TEXT = read_all_files(KB_PATHS)
-
-# Diagnostics: report found / missing in categories
-all_files_set = set(FILES_TEXT.keys())
-category_diagnostics = {}
-for cat, files in LOGIC_PDFS.items():
-    found = [f for f in files if f in all_files_set]
-    missing = [f for f in files if f not in all_files_set]
-    category_diagnostics[cat] = {"found": found, "missing": missing}
-
-# Reorder so priority PDFs appear first (if present)
-ordered_files = {}
-for p in PRIORITY_PDFS:
-    # case-sensitive key match in FILES_TEXT keys (we assume exact naming)
-    for k in list(FILES_TEXT.keys()):
-        if k.lower() == p.lower():
-            ordered_files[k] = FILES_TEXT.pop(k)
-            break
-# add the rest
-for k, v in FILES_TEXT.items():
-    ordered_files[k] = v
-
-FILES_TEXT = ordered_files
+    def query(self, q, top_k=3):
+        out = []
+        for fn, txt in self.docs.items():
+            if q.lower() in txt.lower():
+                out.append((fn, txt[:800]))
+        return out[:top_k]
 
 KB_INDEX = KBIndex()
 KB_INDEX.build_from_files(FILES_TEXT)
 
-# Startup print (diagnostics)
-print("[KB] Indexed files (priority first):")
-for f in FILES_TEXT.keys():
-    print(" -", f)
-
 # -------------------------
-# PARA SF Priority PDFs
+# Operational Command Block
 # -------------------------
-SF_PRIORITY_PDFS = [
-    "Operational Course of Action Using the Kashmir Military Algorithm.pdf",
-    "UPLOAD TO CHAT.pdf",
-    "5D_Crime_Analysis.pdf",
-    "INT_SOP_CONTROL_logic.pdf",
-    "Staff_Officer_Playbook_5D.pdf"
-]
+def operational_command_prompt(answers_map, category):
+    user_text = "\n".join(f"{k}: {v}" for k, v in answers_map.items() if v.strip())
+    return [
+        {"role": "system", "content": SYSTEM_SAFE},
+        {"role": "user", "content": f"""
+You are to prepare a structured, advisory-only report.
 
-print("[KB] Total chunks indexed:", len(KB_INDEX.chunks))
-print("[KB] Category diagnostics (found / missing):")
-for cat, info in category_diagnostics.items():
-    print(f" - {cat}: found={len(info['found'])}, missing={len(info['missing'])}")
+Category: {category}
 
-# -------------------------
-# Safety system prompt (non-actionable)
-# -------------------------
+Inputs:
+{user_text}
 
-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. "
-    "4) DO NOT provide tactical step-by-step instructions."     
+Knowledge base excerpts (if any) must be considered.
 
-# -------------------------
-# Operational Command (plain-English instruction block)
-# Paste this to the top of prompts so the model always follows it.
-# -------------------------
-OPERATIONAL_COMMANDS = """
-OPERATIONAL COMMAND (ADMIN/D0CTRINAL ONLY) — MANDATORY:
-1) PRIORITIZE these KB files when reasoning (priority order):
-   - Operational Course of Action Using the Kashmir Military Algorithm.pdf
-   - UPLOAD TO CHAT.pdf
-   - 5D_Crime_Analysis.pdf
-   - INT_SOP_CONTROL_logic.pdf
-
-2) ALSO CONSULT all other PDFs found in the knowledge_base folder as secondary sources.
-
-3) FOR STANDARD and ENHANCED REPORTS:
-   - DO NOT print the user's questions and answers verbatim in the visible report.
-   - Use the user's answers only as internal context for analysis.
-   - Base your advisory analysis on KB excerpts (cite file::chunk ids).
-   - Provide only administrative, doctrinal, training or audit-style recommendations.
-   - If asked for operational/tactical instructions, REFUSE and offer administrative alternatives.
-
-4) For each incoming question, determine which logic category applies (enemy_detect_information, course_of_action_information, reconnaissance_surveillance, cognitive_and_intelligence, or other) and preferentially use KB excerpts from that category.
-
-5) Always include a short "Sources cited" section that lists the file names and chunk ids that were used to produce the advisory.
-"""
+Report must include:
+- Executive Summary
+- Threat Assessment
+- Course of Action (doctrinal, admin, advisory)
+- Intelligence Summary
+- Administrative Remediations (if applicable)
+        """}
+    ]
 
 # -------------------------
-# Prompt builders (redact Q/A in visible report)
+# Questionnaires
 # -------------------------
-def _shorten(text, n=1200):
-    if not text:
-        return ""
-    return (text[:n] + "…") if len(text) > n else text
-
-def build_standard_prompt_from_retrieved(retrieved_chunks):
-    """
-    Build prompt where KB excerpts are passed to model and Q/A are not echoed.
-    """
-    parts = []
-    parts.append(SYSTEM_SAFE)
-    parts.append(OPERATIONAL_COMMANDS)
-    parts.append("Produce a Standard Advisory Report for a commander.")
-    parts.append("Include: Executive Summary (2-4 lines); Key Administrative Issues (bulleted); Prioritized Administrative Recommendations (numbered); Sources cited (file::chunk ids).")
-    parts.append("Do NOT repeat questions or answers verbatim. Use only KB excerpts below as your primary lens.")
-    parts.append("\n--- KB Excerpts (lens) ---\n")
-    # attach KB excerpts (may have duplicates across questions)
-    added = set()
-    for chunk_list in retrieved_chunks:
-        for c in chunk_list:
-            marker = f"{c['id']}|{c['file']}"
-            if marker in added:
-                continue
-            added.add(marker)
-            parts.append(f"--- {c['id']} (from {c['file']}) ---\n{_shorten(c['text'])}\n")
-    user_text = "\n".join(parts)
-    return [{"role":"system","content":parts[0]}, {"role":"user","content":user_text}]
-
-def build_enhanced_prompt_from_retrieved(retrA, retrB, retrC, gate_text):
-    parts = []
-    parts.append(SYSTEM_SAFE)
-    parts.append(OPERATIONAL_COMMANDS)
-    parts.append("Produce a Enhanced Staff Advisory for a commander.")
-    parts.append("Include: Executive Summary; Key doctrinal/organizational gaps; Prioritized Administrative Remediations; Measurement/audit suggestions; Sources cited.")
-    parts.append("Do NOT repeat questions or answers verbatim. Use KB excerpts below as your primary lens.")
-    parts.append("\n--- KB Excerpts (lens) ---\n")
-    added = set()
-    for clist in (retrA + retrB + retrC):
-        for c in clist:
-            marker = f"{c['id']}|{c['file']}"
-            if marker in added:
-                continue
-            added.add(marker)
-            parts.append(f"--- {c['id']} (from {c['file']}) ---\n{_shorten(c['text'])}\n")
-    if gate_text:
-        parts.append("\nGate assessment (used for analysis, not printed verbatim): [REDACTED]")
-    user_text = "\n".join(parts)
-    return [{"role":"system","content":parts[0]}, {"role":"user","content":user_text}]
 
-# -------------------------
-# Chat API wrapper
-# -------------------------
-def call_chat_api(messages, max_tokens=1400, model="gpt-4o-mini"):
-    if client is None:
-        raise RuntimeError("OpenAI client not initialized. Set OPENAI_API_KEY in the environment.")
-    try:
-        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
-    except Exception as e:
-        raise RuntimeError(f"OpenAI API call failed: {e}")
+STD_QUESTIONS = [
+    "When and 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?",
+    "Do you have Reconnaissance and Surveillance soldiers near the area?",
+    "Did you get the information from local source or army personnel?",
+    "If from local source, did you confirm from a second source or R&S team?",
+    "How far is your commanded army unit from the enemy sighting?",
+    "What is the terrain (urban, jungle, hilly, rural)?"
+]
 
-# -------------------------
-# Deterministic remediation helpers (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.")
-    # dedupe
-    out = []
-    for r in rem:
-        if r not in out:
-            out.append(r)
-    return out
-
-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.")
-    out = []
-    for r in rem:
-        if r not in out:
-            out.append(r)
-    return out
+ENH_SECTION_A = [
+    "Does the Bn have separate Ops planning and Int sections?",
+    "Does the Unit have int SOP? Any COA template?",
+    "Does the unit have a reconnaissance and surveillance plan?",
+    "Does the unit have Force Protection SOP / Threat Levels?",
+    "Does the unit have intelligence projection capability?"
+]
 
-# -------------------------
-# Report generation functions
-# -------------------------
-def generate_standard_report_with_lens(answers_map, kb_index, top_k_per_answer=3):
-    # Map each STD question to a logic category (enemy_detect_information for detection questions)
-    # For simplicity: use enemy_detect_information for STD questions
-    retrieved = []
-    prefer_files = LOGIC_PDFS.get("enemy_detect_information", []) + PRIORITY_PDFS
-    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, prefer_files=prefer_files)
-        retrieved.append(chunks)
-    messages = build_standard_prompt_from_retrieved(retrieved)
-    # Force OpenAI call
-    try:
-        out = call_chat_api(messages, max_tokens=1400)
-        return out
-    except Exception as e:
-        # deterministic fallback
-        lines = ["[FALLBACK NON-ACTIONABLE STANDARD ADVISORY]\n"]
-        lines.append("Executive Summary: (derived administratively from inputs and KB)")
-        # For each question, only list admin remediation if answer negative
-        for i, q in enumerate(STD_QUESTIONS):
-            a = answers_map.get(q, "")
-            if not a or str(a).strip().lower() in ("", "no", "n", "none", "negative"):
-                lines.append(f"- Deficiency: {q}")
-                for r in remediation_for_std_question(q):
-                    lines.append(f"  *Admin remediation:* {r}")
-        lines.append("\nSources: (KB unavailable or OpenAI unreachable)")
-        return "\n".join(lines)
-
-def generate_enhanced_report_with_lens(a_map, b_map, c_map, gate_text, kb_index, top_k_per_answer=3):
-    # Map Enhanced sections to categories
-    # Section A -> reconnaissance_surveillance
-    # Section B -> course_of_action_information
-    # Section C -> cognitive_and_intelligence
-    retrieved_A = [kb_index.retrieve(str(a_map.get(q,"") or q), top_k=top_k_per_answer, prefer_files=LOGIC_PDFS.get("reconnaissance_surveillance", []) + PRIORITY_PDFS) for q in ENH_SECTION_A]
-    retrieved_B = [kb_index.retrieve(str(b_map.get(q,"") or q), top_k=top_k_per_answer, prefer_files=LOGIC_PDFS.get("course_of_action_information", []) + PRIORITY_PDFS) for q in ENH_SECTION_B]
-    retrieved_C = [kb_index.retrieve(str(c_map.get(q,"") or q), top_k=top_k_per_answer, prefer_files=LOGIC_PDFS.get("cognitive_and_intelligence", []) + PRIORITY_PDFS) for q in ENH_SECTION_C]
-    messages = build_enhanced_prompt_from_retrieved(retrieved_A, retrieved_B, retrieved_C, gate_text)
-    try:
-        out = call_chat_api(messages, max_tokens=1600)
-        return out
-    except Exception as e:
-        lines = ["[FALLBACK ENHANCED ADVISORY]\n"]
-        lines.append("Administrative gaps and remediations:\n")
-        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}")
-        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}")
-        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("\nSources: (OpenAI unreachable or KB partial)")
-        return "\n".join(lines)
+ENH_SECTION_B = [
+    "Is there a vulnerability analysis tool for unit?",
+    "Does the unit employ randomness in movement?",
+    "Is there a source vetting system in place?",
+    "Does the unit treat intelligence as doctrine or just info?",
+    "Does the unit use counterintelligence in vulnerability analysis?"
+]
 
-# -------------------------
-# Threat readiness
-# -------------------------
-def evaluate_threat_brief_from_answers(all_vals):
-    total = len(STD_QUESTIONS) + len(ENH_SECTION_A) + len(ENH_SECTION_B) + len(ENH_SECTION_C)
-    vals = list(all_vals)[:total] + [""] * max(0, total - len(all_vals))
-    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"
-
-    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))
-
-    unique_rems = []
-    for r in rems:
-        if r not in unique_rems:
-            unique_rems.append(r)
-
-    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)")
-    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)
-# -------------------------
-# PARA SF Questionnaires (paste before UI)
-# -------------------------
+ENH_SECTION_C = [
+    "Are int personnel embedded in routine ops?",
+    "Am I thinking of Threat or CO’s Situational Awareness?",
+    "What is my intent as Staff planning element?",
+    "Do I detect, deter, deny, deliver, or destroy?",
+    "Do external MI assets conform to 5D system?",
+    "Did I make vulnerability assessment based on Deter and Deny?",
+    "How do I account for Force Protection?",
+    "Do we attack threats’ SA, movement, tactics, or support?",
+    "Is the call deliberate or quick?",
+    "Do I clearly distinguish Warn, Surprise, SA?"
+]
 
+# PARA SF Qs
 PARA_QUESTIONS_50 = [
-"When and at what exact location was the enemy last observed?",
-"What was the precise timestamp (date & local time) of the sighting?",
-"From which direction or axis did the observed elements approach?",
-"What is the estimated size (number of personnel) of the enemy element?",
-"What is the observed role-composition (fighters, leaders, logistics, lookouts) of the enemy?",
-"What weapons and equipment were seen (small arms, heavy weapons, explosives)?",
-"Were vehicles observed? If yes, type, count and mobility characteristics?",
-"Were they mounted, motorized or on foot during the sighting?",
-"What is the enemy’s formation, spacing and dispersion at point of observation?",
-"What observable movement pattern or tactics were used (patrol, rush, bypass, hide)?",
-"Did enemy show identifiable signs, clothing, insignia or leader marks?",
-"Were candidate leaders or command figures visible or identifiable?",
-"Was there evidence of enemy communications (radios, burst transmissions, messengers)?",
-"Was any electronic emissions or comms pattern observed (bursts, silence, specific frequencies)?",
-"How far is the sighting from nearest military route/road used by your forces (meters/km)?",
-"How far is the sighting from your closest unit, patrol or base (meters/km)?",
-"What civilian infrastructure is nearest (market, school, clinic) and its distance?",
-"Was there any civilian activity at the site and did civilians appear to support/assist the enemy?",
-"Any signs of cached supplies, recent logistics activity, or prepared hide sites?",
-"Does the area show signs of recent digging, caches, or concealed stores?",
-"Is the terrain at sighting urban / semi-urban / rural / hilly / jungle / mixed?",
-"What were visibility and weather conditions at the time (day/night, rain, fog)?",
-"Did enemy employ surveillance or target-casing behaviour before movement?",
-"Do you observe enemy counter-surveillance (watching for being followed or observed)?",
-"Were there scouts, pickets or early-warning elements deployed by the enemy?",
-"Is the enemy using deceptive measures (dummy positions, false reports, signals)?",
-"Are there known or suspected safe houses, support homes, or sympathiser nodes nearby?",
-"What is known of enemy resupply methods and routes (timings, vehicles, mule lines)?",
-"Is there evidence of medical support or casualty evacuation capability for the enemy?",
-"Does the enemy have known heavy/indirect fire capability (mortars, rockets, heavy MGs)?",
-"Does the enemy use snipers, suppressive fire or sniper traps in this AO?",
-"Has the enemy adapted tactics recently after prior engagements in this AO?",
-"Are there predictable daily/weekly/seasonal patterns in enemy activity or movement?",
-"Does the enemy blend with civilians or use noncombatant cover deliberately?",
-"Are there known local criminal networks or cartels supporting the enemy (who)?",
-"Is there evidence of external support (cross-border aid, funding, materiel)?",
-"Does the enemy attempt to monitor or catalogue your unit routines (patrol times, routes)?",
-"Was the sighting corroborated by more than one independent source? If so, which?",
-"What is your confidence level in this sighting (low/medium/high) and why?",
-"What immediate intelligence priorities do you request (confirm size, leadership ID, caches)?",
-"What follow-up sensors or surveillance (R&S teams, OPs, HI/geo) have been or should be tasked?",
-"Does historical KB / previous incidents indicate likely COA (ambush, raid, VBIED, sabotage)?",
-"Based on available information, what is the most likely short-term enemy intent?",
-"What is the most dangerous unknown (highest intelligence gap) right now?",
-"Does the local population sentiment appear supportive, neutral or hostile to security forces?",
-"Are there legal or agency actors (police/DEA/other) operating in the AO that affect options?",
-"Are there choke points, key nodes, or likely avenues of approach the enemy favours?",
-"Has the enemy demonstrated capability to rehearse or coordinate complex multi-axis attacks?"
+    f"Enemy Q{i+1}" for i in range(50)
 ]
-
 PARA_PRECAUTIONS_40 = [
-"Confirm all SITREP entries include mandatory geo/time/observer-confidence fields.",
-"Require secondary confirmation for any local-source reporting before escalation.",
-"Maintain a vetted source registry with CI provenance tags and access controls.",
-"Institute scheduled CI audits for HUMINT sources and reporting teams.",
-"Publish and maintain an SR (Special Reconnaissance) activation roster and SOP.",
-"Define and enforce SR reporting formats: mandatory fields, cadence, secure channels.",
-"Embed intelligence liaisons in checkpoints, patrol briefings and R&S handovers.",
-"Maintain and regularly update a Base Vulnerability Register for critical assets.",
-"Conduct quarterly administrative red-team tabletop reviews on vulnerability findings.",
-"Implement and document randomness in routine movements and patrol timings.",
-"Require route-planning checklists and formal Force Protection (FP) reviews prior to movement.",
-"Document force-protection escalation triggers and make them accessible to command.",
-"Define covert Tactical C2 naming/concealment conventions and secure comms policy.",
-"Document activation triggers and minimum manning for forward intelligence projection nodes.",
-"Maintain a cache registry with audit trails (who accessed, when, purpose) for clandestine stores.",
-"Produce a daily local-threat mapping product for Area HQ use (doctrinal template).",
-"Institute structured data-sharing protocols with police, DEA and partner agencies (MOUs).",
-"Mandate CI cross-checks on sudden influx of local ‘helpful’ reports and mark for audit.",
-"Schedule regular SR tradecraft refresher training and surveillance-detection drills.",
-"Publish a Source Confidence Matrix and require staff to consult it in assessments.",
-"Define Ops-Int liaison roles with formal RACI and documented responsibilities.",
-"Create a 5D Decision Matrix template for staff planners and force protection planners.",
-"Maintain and review a prioritized HVT administrative monitoring list with owners.",
-"Require observation-post (OP) turnover logs, admin inspections and OP checklists.",
-"Mandate redundant secure reporting channels with redundancy and audit logs.",
-"Maintain a lessons-learned register populated after each R&S mission (admin only).",
-"Publish legal/command guidance on engagement-of-locals policies and vetting before use.",
-"Retain and update terrain overlays and likely enemy use-case scenarios for staff reference.",
-"Establish MOUs to permit relevant cross-agency intelligence shares where lawful.",
-"Use doctrine-approved checklists before activating covert nodes inside populated zones.",
-"Require anonymized HUMINT entries for sensitive sources and log access for audits.",
-"Schedule periodic audits of comms metadata logs for administrative oversight.",
-"Create formal SOPs for suspected planted/false sources and double-agent indicators.",
-"Maintain a documented forensic/evidence-collection admin procedure (non-operational).",
-"Run regular table-top exercises on surprise events and deception scenarios (admin focus).",
-"Institute 'intelligence sanity-checks' requiring at least two KB sources to align for high-confidence claims.",
-"Require an audit record for every SR insertion or surveillance emplacement.",
-"Mandate periodic cross-validation of terrain/use overlays by staff planners.",
-"Publish a one-page WARN card for commanders (color-coded triggers and contacts)."
+    f"Precaution {i+1}" for i in range(40)
 ]
 
- 
- 
- 
-
-
 # -------------------------
-# Doctrinal summary constant
+# Report Generators
 # -------------------------
-DOCTRINAL_SUMMARY_DETAILED = """
-# 📘 Doctrinal Summary (Sanitized, Detailed)
-
-Purpose and Approach
-- Intelligence is treated as a combat function, not just support. Adversaries (cartels, terrorists, insurgents) have quasi-military structures that must be mapped and targeted using intelligence architectures.
-- Objective: Give the commander a persistent, adaptive situational picture by embedding Command, Control, Communications, Intelligence, Surveillance, Reconnaissance (C3ISR) across the AO.
-- Scope: Covers architecture, zoning, collection posture, force protection, staff planning, and doctrinal lenses. No tactical timings or unit counts are provided here.
+def generate_report_with_kb(answers_map, category, top_k=3):
+    kb_hits = []
+    for q, a in answers_map.items():
+        if not a.strip():
+            continue
+        kb_hits.extend(KB_INDEX.query(q, top_k=top_k))
+    excerpt_text = "\n".join(f"{fn}: {txt}" for fn, txt in kb_hits)
+    prompt = operational_command_prompt(answers_map, category)
+    if excerpt_text:
+        prompt[1]["content"] += f"\nKnowledge Base excerpts:\n{excerpt_text}\n"
+    try:
+        resp = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=prompt,
+            max_tokens=700
+        )
+        return resp.choices[0].message.content.strip()
+    except Exception as e:
+        return f"[Error generating report: {e}]"
 
-(Excerpt sanitized — administrative doctrinal guidance only.)
-"""
+# PARA SF Inference
+def para_sf_inference_runner(selected_files, pasted, answers_map):
+    kb_hits = []
+    for q, a in answers_map.items():
+        if not a.strip():
+            continue
+        kb_hits.extend(KB_INDEX.query(q, top_k=2))
+    excerpt_text = "\n".join(f"{fn}: {txt}" for fn, txt in kb_hits)
+    user_text = "\n".join(f"{k}: {v}" for k,v in answers_map.items() if v.strip())
+    prompt = [
+        {"role":"system","content":SYSTEM_SAFE},
+        {"role":"user","content":f"""
+Prepare PARA SF non-actionable advisory. Use 5D system lens.
+
+Inputs:
+{user_text}
+
+Fieldcraft notes:
+{pasted}
+
+Knowledge Base excerpts:
+{excerpt_text}
+
+Report must include:
+- Doctrinal Course of Action
+- Threat Assessment
+- Intelligence Summary
+- PARA SF Precautions & Protective Measures
+        """}
+    ]
+    try:
+        resp = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=prompt,
+            max_tokens=800
+        )
+        return resp.choices[0].message.content.strip()
+    except Exception as e:
+        return f"[Error running PARA SF inference: {e}]"
 
 # -------------------------
-# Gradio UI (preserve your two tabs; add doctrinal & threat)
+# UI
 # -------------------------
 with gr.Blocks() as demo:
     gr.HTML(f'<img src="{BANNER_URL}" width="100%">')
-    gr.Markdown("# Kashmir AO Action Plan for Inf — Army Analyst Tool & Battle Planner (Sanitized)")
+    gr.Markdown("# Kashmir AOR Action Plan — Battle Planner")
 
-    # ----------- Standard Analyst Tab -----------
-    with gr.Tab("Standard Analyst"):
+    with gr.Tab("Standard"):
         std_inputs = [gr.Textbox(label=q, lines=1) for q in STD_QUESTIONS]
-        std_btn = gr.Button("Generate Standard Advisory (KB-lens)")
-        std_output = gr.Textbox(label="Standard Advisory (sanitized)", lines=30)
-        def on_std_click(*answers):
+        std_button = gr.Button("Generate Standard Advisory")
+        std_output = gr.Textbox(label="Standard Advisory Report", lines=28)
+        def std_runner(*answers):
             amap = dict(zip(STD_QUESTIONS, answers))
-            try:
-                return generate_standard_report_with_lens(amap, KB_INDEX, top_k_per_answer=3)
-            except Exception as e:
-                return f"[Error generating Standard Advisory: {e}]\n\nEnsure OPENAI_API_KEY is set and KB files are accessible in /mnt/data/knowledge_base or /mnt/data."
-        std_btn.click(on_std_click, inputs=std_inputs, outputs=std_output)
-
-    # ----------- Enhanced Analyst Tab -----------
-    with gr.Tab("Enhanced Analyst (Sectioned)"):
+            return generate_report_with_kb(amap, "Standard Threat Advisory")
+        std_button.click(std_runner, inputs=std_inputs, outputs=std_output)
+
+    with gr.Tab("Enhanced"):
         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_q = gr.Textbox(label="Gate Assessment (commander's final note) — used for analysis only", lines=1)
-        enh_btn = gr.Button("Generate Enhanced Advisory (KB-lens)")
-        enh_output = gr.Textbox(label="Enhanced Advisory (sanitized)", lines=36)
-        def on_enh_click(*args):
-            la = len(ENH_SECTION_A); lb = len(ENH_SECTION_B); lc = len(ENH_SECTION_C)
-            vals = list(args)
-            while len(vals) < (la+lb+lc+1):
-                vals.append("")
-            a_vals = vals[:la]; b_vals = vals[la:la+lb]; c_vals = vals[la+lb:la+lb+lc]; gate_val = vals[-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))
-            try:
-                return generate_enhanced_report_with_lens(a_map, b_map, c_map, gate_val, KB_INDEX, top_k_per_answer=3)
-            except Exception as e:
-                return f"[Error generating Enhanced Advisory: {e}]\n\nEnsure OPENAI_API_KEY is set and KB files are accessible."
-        enh_btn.click(on_enh_click, inputs=a_inputs+b_inputs+c_inputs+[gate_q], outputs=enh_output)
-
-    # ----------- Doctrinal Summary Tab -----------
-    with gr.Tab("Doctrinal Summary (Sanitized, Detailed)"):
-        gr.Markdown(DOCTRINAL_SUMMARY_DETAILED)
-
-    # ----------- Threat Readiness Tab -----------
-    with gr.Tab("Threat Readiness"):
-        gr.Markdown("## Threat Readiness — color-coded commander brief (administrative only)")
-        std_state = gr.State()
-        a_state = gr.State()
-        b_state = gr.State()
-        c_state = gr.State()
-
-        # Capture answers when reports are generated
-        def cache_std(*answers):
-            return list(answers)
-        std_btn.click(cache_std, inputs=std_inputs, outputs=[std_state])
-
-        def cache_enh(*answers):
+        gate_input = gr.Textbox(label="Gate Question", lines=1)
+        enh_button = gr.Button("Generate Enhanced Advisory")
+        enh_output = gr.Textbox(label="Enhanced Advisory Report", lines=28)
+        def enh_runner(*answers):
             la, lb, lc = len(ENH_SECTION_A), len(ENH_SECTION_B), len(ENH_SECTION_C)
-            a_vals = answers = list(args for args in args_for_dummy())  # placeholder if needed
-            # but we'll use the outputs from enh_btn click defined above to supply state
-            # here we implement simple caching via the click triggered on the enh_btn (see below)
-            return None
-
-        # Because Gradio wiring for caching enhanced answers is done via the main click above,
-        # provide a direct Threat evaluator button that expects user to have generated both reports already.
-        threat_btn = gr.Button("Evaluate Threat Readiness (based on last filled answers)")
-        threat_output = gr.Textbox(label="Threat Readiness & Admin Diagnostics", lines=30)
-
-        # For simplicity, implement a function that reads the current inputs on demand
-        def threat_runner_live(*ignore):
-            # collect current values from the input widgets via the demo state (we accept they were filled)
-            # To avoid complex state wiring, require the user to press the "Generate Standard Advisory" and "Generate Enhanced Advisory"
-            # buttons first; the app warns otherwise.
-            return ("To evaluate threat readiness: please first generate the Standard Advisory (press the button in the Standard tab) "
-                    "and the Enhanced Advisory (press the button in the Enhanced tab). This will cache the answers and permit a full assessment."
-                    "\n\nNote: threat readiness evaluates administrative readiness and lists deficiencies and remediations only.")
-        threat_btn.click(threat_runner_live, inputs=None, outputs=threat_output)
-
-    # ----------- Diagnostics accordion -----------
-    with gr.Accordion("Operational notes & diagnostics (admin only)", open=False):
-        # Show which KB files were indexed and category diagnostics
-        files_list_md = "\n".join(f"- {k}" for k in FILES_TEXT.keys()) if FILES_TEXT else "- [NO KB FILES FOUND]"
-        diag_md = (
-            f"**Indexed KB files (priority first):**\n\n{files_list_md}\n\n"
-            f"**Total KB chunks indexed:** {len(KB_INDEX.chunks)}\n\n"
-            "**Category diagnostics:**\n"
-        )
-        for cat, info in category_diagnostics.items():
-            diag_md += f"- {cat}: found={len(info['found'])}, missing={len(info['missing'])}\n"
-            if info['missing']:
-                diag_md += f"  - Missing: {info['missing']}\n"
-        gr.Markdown(diag_md)
-        if client is None:
-            gr.Markdown("**OpenAI client: NOT INITIALIZED** — set OPENAI_API_KEY to enable GPT-based advisory reports.")
-        else:
-            gr.Markdown("**OpenAI client: OK**")
+            amap = dict(zip(ENH_SECTION_A+ENH_SECTION_B+ENH_SECTION_C, answers[:la+lb+lc]))
+            return generate_report_with_kb(amap, "Enhanced Threat Advisory")
+        enh_button.click(enh_runner, inputs=a_inputs+b_inputs+c_inputs+[gate_input], outputs=enh_output)
 
-# -------------------------
-# Launch
-# -------------------------
-with gr.Tab("PARA SF (Two Reports)"):
-    gr.Markdown("## PARA SF — Two Separate Administrative Advisories (Non-Actionable)")
-
-    # Question inputs (50)
-    para_questions_inputs = [gr.Textbox(label=q, lines=1) for q in PARA_QUESTIONS_50]
-
-    # Paste box for SR / human-intel notes
-    para_fieldcraft = gr.Textbox(label="Paste Fieldcraft / SR notes (your text)", lines=6)
-
-    # File selector for SF KB files (optional; leave blank to use defaults)
-    para_file_selector = gr.CheckboxGroup(
-        choices=SF_PRIORITY_PDFS,
-        label="Select SF KB files to use (optional — leave blank to use default SF-priority files)"
-    )
-
-    # Buttons for two separate advisories
-    para_coa_btn = gr.Button("Generate COA / Threat Assessment / Intelligence Summary")
-    para_prec_btn = gr.Button("Generate PARA SF Precautions & Protective Advisory")
-
-    # Outputs (two separate textboxes)
-    para_coa_out = gr.Textbox(label="COA / Threat Assessment / Intelligence Summary (sanitized)", lines=28)
-    para_prec_out = gr.Textbox(label="PARA SF Precautions & Protective Measures (sanitized)", lines=28)
-
-    # Runner helpers (these call the sanitized para_sf_inference_runner and then try to extract sections)
-    def _extract_section(full_text, markers):
-        """Return substring beginning at first marker found, or None."""
-        if not full_text:
-            return None
-        for m in markers:
-            idx = full_text.find(m)
-            if idx != -1:
-                # return from marker to marker+max or end
-                return full_text[idx: idx + 4000] if len(full_text) > idx+4000 else full_text[idx:]
-        return None
-
-    def para_coa_runner(*all_inputs):
-        # last two inputs are fieldcraft and file_selector
-        answers = list(all_inputs[:-2])
-        pasted = all_inputs[-2] or ""
-        selected = all_inputs[-1] or []
-        # map answers
-        answers_map = dict(zip(PARA_QUESTIONS_50, answers))
-        # call sanitized engine
-        try:
-            full = para_sf_inference_runner(selected, pasted, answers_map)
-        except Exception as e:
-            full = f"[Error running PARA SF inference: {e}]"
-        # try extract COA / Threat Assessment / Intelligence Summary
-        markers = [
-            "Doctrinal Course of Action", "Course of Action", "COA", 
-            "Threat Assessment", "Intelligence Summary", "Executive Summary"
-        ]
-        sec = _extract_section(full, markers)
-        return sec or full
-
-    def para_prec_runner(*all_inputs):
-        answers = list(all_inputs[:-2])
-        pasted = all_inputs[-2] or ""
-        selected = all_inputs[-1] or []
-        answers_map = dict(zip(PARA_QUESTIONS_50, answers))
-        try:
-            full = para_sf_inference_runner(selected, pasted, answers_map)
-        except Exception as e:
-            full = f"[Error running PARA SF inference: {e}]"
-        # try extract precautionary measures section
-        markers = [
-            "Precautions", "Protective Measures", "Para SF Precautions", 
-            "Precautionary Measures", "Administrative Remediations"
-        ]
-        sec = _extract_section(full, markers)
-        # If we couldn't find a specific list, try to assemble from PARA_PRECAUTIONS_40 deterministic advisories
-        if sec:
-            return sec
-        else:
-            # fallback: try to synthesize a prioritized 10-item TACTICAL precautions list deterministically
-            lines = ["[Fallback: Admin Precautions — OpenAI output did not include clear Precautions section]"]
-            # pick top N items from PARA_PRECAUTIONS_40 and show remediation+audit stub
-            for i, itm in enumerate(PARA_PRECAUTIONS_40[:12], start=1):
-                lines.append(f"{i}. {itm} — Remediation: Implement & document. Audit: quarterly check.")
-            lines.append("\nFull report (if produced):\n")
-            lines.append(full[:4000])
+    with gr.Tab("Threat Readiness"):
+        gr.Markdown("## Threat Readiness — Color-coded Commander Brief")
+        threat_button = gr.Button("Evaluate Threat Readiness")
+        threat_output = gr.Textbox(label="Threat Readiness & Diagnostics", lines=28)
+        def evaluate_threat_brief():
+            lines = []
+            lines.append("### Threat Readiness Level (Color-coded)")
+            lines.append("- 🔴 RED (<50%): Severe vulnerabilities.")
+            lines.append("- 🟠 ORANGE (50–69%): Moderate vulnerabilities.")
+            lines.append("- 🔵 BLUE (70–84%): Minor gaps.")
+            lines.append("- 🟢 GREEN (85–100%): Good readiness.\n")
+            lines.append("Commander’s Brief: Review deficiencies and remediation schedule.")
             return "\n".join(lines)
-
-    # Wire buttons
-    para_coa_btn.click(para_coa_runner, inputs=para_questions_inputs + [para_fieldcraft, para_file_selector], outputs=para_coa_out)
-    para_prec_btn.click(para_prec_runner, inputs=para_questions_inputs + [para_fieldcraft, para_file_selector], outputs=para_prec_out)
+        threat_button.click(evaluate_threat_brief, inputs=[], outputs=threat_output)
+
+    with gr.Tab("PARA SF (Two Reports)"):
+        para_questions_inputs = [gr.Textbox(label=q, lines=1) for q in PARA_QUESTIONS_50]
+        para_fieldcraft = gr.Textbox(label="Paste Fieldcraft / SR notes", lines=6)
+        para_file_selector = gr.CheckboxGroup(choices=SF_PRIORITY_PDFS, label="Select SF KB files")
+        para_coa_btn = gr.Button("Generate COA / Threat Assessment / Intelligence Summary")
+        para_prec_btn = gr.Button("Generate PARA SF Precautions & Protective Advisory")
+        para_coa_out = gr.Textbox(label="COA / Threat Assessment / Intelligence Summary", lines=28)
+        para_prec_out = gr.Textbox(label="PARA SF Precautions & Protective Measures", lines=28)
+        def para_coa_runner(*all_inputs):
+            amap = dict(zip(PARA_QUESTIONS_50, all_inputs[:-2]))
+            pasted = all_inputs[-2] or ""
+            selected = all_inputs[-1] or []
+            return para_sf_inference_runner(selected, pasted, amap)
+        def para_prec_runner(*all_inputs):
+            amap = dict(zip(PARA_QUESTIONS_50, all_inputs[:-2]))
+            pasted = all_inputs[-2] or ""
+            selected = all_inputs[-1] or []
+            return para_sf_inference_runner(selected, pasted, amap)
+        para_coa_btn.click(para_coa_runner, inputs=para_questions_inputs+[para_fieldcraft, para_file_selector], outputs=para_coa_out)
+        para_prec_btn.click(para_prec_runner, inputs=para_questions_inputs+[para_fieldcraft, para_file_selector], outputs=para_prec_out)
 
 if __name__ == "__main__":
     demo.launch()