Update APPC.py

APPC.py

@@ -1,719 +1,209 @@
-# 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 gradio as gr
-
-# 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 = "https://huggingface.co/spaces/Militaryint/ops/resolve/main/banner.png"
+from openai import OpenAI
 
 # -------------------------
-# QUESTIONS (exact phrasing you requested)
+# OpenAI client
 # -------------------------
-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?"
-]
-
-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_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?"
-]
-
-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?"
-]
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
 # -------------------------
-# 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",
     "5D_Crime_Analysis.pdf",
-    "INT_SOP_CONTROL_logic.pdf"
+    "INT_SOP_CONTROL_logic.pdf",
 ]
 
-# -------------------------
-# File reading & chunking (larger chunks for richer context)
-# -------------------------
-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
-
-# -------------------------
-# Embeddings & retrieval helpers
-# -------------------------
-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}
-    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
-
-# -------------------------
-# Load KB files (priority path knowledge_base)
-# -------------------------
-KB_PATHS = ["/mnt/data/knowledge_base", "/mnt/data"]
-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
-
-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)
-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'])}")
-
-# -------------------------
-# Safety system prompt (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. "
-    "4) DO NOT provide tactical step-by-step instructions."
-)
-
-# -------------------------
-# 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.
-"""
-
-# -------------------------
-# Prompt builders (redact Q/A in visible report)
-# -------------------------
-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 NON-ACTIONABLE 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 NON-ACTIONABLE 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}]
+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"
+]
 
 # -------------------------
-# 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}")
+# PARA SF Questions (50)
+# -------------------------
+PARA_QUESTIONS_50 = [
+    "Where was the enemy sighted?",
+    "At what time was the enemy detected?",
+    "What is the size of the enemy force?",
+    "What is the disposition/formation of the enemy?",
+    "What weapons and equipment are they carrying?",
+    "Are they supported by vehicles or on foot?",
+    "What direction are they approaching from?",
+    "How far are they from main supply routes?",
+    "How far are they from friendly bases?",
+    "Are they near civilian population centers?",
+    "Do they have air or drone support?",
+    "What is their reconnaissance capability?",
+    "What is their fire support capability?",
+    "Have they employed snipers?",
+    "What is their past history of ambushes?",
+    "What is their maneuver style?",
+    "Are they centralized or dispersed?",
+    "Are they supported by locals?",
+    "Which groups of locals support them?",
+    "Are they conducting deception operations?",
+    "Are they blending with civilian population?",
+    "Have they planted false information sources?",
+    "What is the terrain (urban, jungle, hills, rural)?",
+    "Do they exploit night movement?",
+    "What is their communication capability?",
+    "Are they radio silent?",
+    "Are they using couriers?",
+    "Are they using tunnels or hidden routes?",
+    "Are they mining or IED laying?",
+    "Are they targeting leadership?",
+    "Are they targeting logistics routes?",
+    "Have they conducted psychological ops?",
+    "What is their morale level?",
+    "Do they avoid direct contact?",
+    "Have they attacked critical infrastructure?",
+    "What infiltration methods do they prefer?",
+    "Do they coordinate with other hostile groups?",
+    "Are they foreign trained?",
+    "What camouflage or disguise do they use?",
+    "Are they probing defenses?",
+    "Have they rehearsed observed tactics?",
+    "Do they use women/children as informants?",
+    "Are they equipped for prolonged firefight?",
+    "Do they retreat quickly after attacks?",
+    "Have they used suicide attackers?",
+    "Do they use cyber or electronic warfare?",
+    "What intelligence capabilities do they possess?",
+    "Do they adapt tactics quickly?",
+    "Have they mapped friendly positions?",
+    "Do they exploit weather or festivals?",
+]
 
 # -------------------------
-# 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
+# PARA SF Precautions (40)
+# -------------------------
+PARA_PRECAUTIONS_40 = [
+    "Rotate patrol timings to prevent enemy surveillance patterning.",
+    "Use counter-surveillance teams on all movements.",
+    "Deploy deception convoys to mislead enemy observers.",
+    "Maintain strict radio discipline with burst transmissions.",
+    "Conceal movement using terrain masking.",
+    "Randomize entry and exit points of patrols.",
+    "Vary resupply routes and timings.",
+    "Conduct route clearance with mine detection.",
+    "Maintain local informant vetting system.",
+    "Employ reconnaissance drones for forward scanning.",
+    "Deploy early warning observation posts.",
+    "Integrate snipers for overwatch on patrols.",
+    "Use noise/light discipline at night.",
+    "Rehearse immediate ambush reaction drills.",
+    "Conduct periodic camp perimeter red-teaming.",
+    "Disperse high-value assets across base.",
+    "Rotate guard posts unpredictably.",
+    "Conduct deception radio chatter.",
+    "Run regular psychological operations to counter enemy influence.",
+    "Screen all civilian entrants to bases.",
+    "Harden logistics convoys with escort vehicles.",
+    "Rehearse casualty evacuation drills.",
+    "Regularly sanitize friendly comms from leaks.",
+    "Embed intelligence staff with operations.",
+    "Maintain tactical quick reaction force alert.",
+    "Rotate unit sectors periodically.",
+    "Employ camouflage nets on vehicles.",
+    "Reinforce gate security procedures.",
+    "Test night vision capability under field stress.",
+    "Create fallback positions in base defense.",
+    "Enforce strict OPSEC for families.",
+    "Maintain reserve ammunition caches.",
+    "Regularly train troops in civilian blending.",
+    "Deploy dummy positions to confuse enemy recon.",
+    "Audit source registry quarterly.",
+    "Cross-check intelligence feeds with CI.",
+    "Run deception exercises periodically.",
+    "Embed force protection analysts with staff.",
+    "Maintain contingency withdrawal routes.",
+    "Audit cyber hygiene and device discipline."
+]
 
 # -------------------------
-# Report generation functions
+# PARA SF Inference Runner
 # -------------------------
-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
+def para_sf_inference_runner(selected_files, pasted_notes, answers_map):
     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
+        # Context building — do NOT echo raw Q&A
+        context = []
+        if pasted_notes:
+            context.append("Fieldcraft / SR notes provided:\n" + pasted_notes)
+        if selected_files:
+            context.append("Priority SF doctrinal PDFs used:\n" + ", ".join(selected_files))
+
+        # Instead of feeding raw Q&A text, only tell model answers exist
+        if any(v.strip() for v in answers_map.values()):
+            context.append("Commander has provided a full set of answers. Use them through the 5D lens to infer threat, COAs, intelligence summary, and precautions. Do NOT restate questions or answers. Only provide advisory conclusions.")
+
+        full_prompt = "\n\n".join(context) if context else "No inputs."
+
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are an SF doctrinal analyst. Use PARA SF doctrine, 5D Crime Analysis, Kashmir Algorithm, and uploaded PDFs to produce threat assessments, COAs, intelligence summaries, and protective measures. Never output raw Q&A. Never output attack tactics. Only defensive readiness."},
+                {"role": "user", "content": full_prompt}
+            ],
+            temperature=0.4,
+            max_tokens=1200,
+        )
+        return response.choices[0].message.content
     except Exception as e:
-        lines = ["[FALLBACK NON-ACTIONABLE 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)
+        return f"[Error in PARA SF runner: {e}]"
 
 # -------------------------
-# Threat readiness (administrative only)
-# -------------------------
-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)
-
-# -------------------------
-# Doctrinal summary constant
-# -------------------------
-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.
-
-(Excerpt sanitized — administrative doctrinal guidance only.)
-"""
-
-# -------------------------
-# Gradio UI (preserve your two tabs; add doctrinal & threat)
+# Gradio App
 # -------------------------
 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)")
-
-    # ----------- Standard Analyst Tab -----------
-    with gr.Tab("Standard Analyst"):
-        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):
-            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)"):
-        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()
+    gr.Markdown("# Kashmir AOR Battle Planner")
 
-        # Capture answers when reports are generated
-        def cache_std(*answers):
-            return list(answers)
-        std_btn.click(cache_std, inputs=std_inputs, outputs=[std_state])
+    with gr.Tab("PARA SF (Two Reports)"):
+        gr.Markdown("## PARA SF — Administrative Non-Actionable Advisories")
 
-        def cache_enh(*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
+        para_questions_inputs = [gr.Textbox(label=q, lines=1) for q in PARA_QUESTIONS_50]
+        para_fieldcraft = gr.Textbox(label="Paste SR / fieldcraft notes", lines=6)
 
-        # 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"
+        para_file_selector = gr.CheckboxGroup(
+            choices=SF_PRIORITY_PDFS,
+            label="Select SF KB files (optional)"
         )
-        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**")
 
-# -------------------------
-# Launch
-# -------------------------
+        para_coa_btn = gr.Button("Generate COA / Threat Assessment / Intel 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="Precautions & Protective Measures", lines=28)
+
+        def para_coa_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))
+            return para_sf_inference_runner(selected, pasted, answers_map)
+
+        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))
+            full = para_sf_inference_runner(selected, pasted, answers_map)
+            if any(m in full for m in ["Precautions", "Protective", "Measures"]):
+                return full
+            else:
+                lines = ["[Fallback Precautions]"]
+                for i, itm in enumerate(PARA_PRECAUTIONS_40[:12], start=1):
+                    lines.append(f"{i}. {itm} — Remediation: Implement & audit quarterly.")
+                return "\n".join(lines)
+
+        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()