Update app.py

app.py

@@ -1,533 +1,149 @@
-# app.py
-
-import os, re
-import gradio as gr
-from openai import OpenAI
-from pathlib import Path
-from PyPDF2 import PdfReader
-
-# -------------------------
-# Banner URL
-# -------------------------
-BANNER_URL = "https://huggingface.co/spaces/Militaryint/ops/resolve/main/banner.png"
-
-# -------------------------
-# Safety Block
-# -------------------------
-SYSTEM_SAFE = """
-You are a military analyst assistant. 
-All outputs must remain ACTIONABLE,  and advisory tactical army -only. 
-
+"""
+ARMYINTEL 5D–MDMP Training Engine
+Purpose: Non‑kinetic military‑intelligence analysis simulator for education and defence training.
+Frameworks: 5D (Detect–Deter–Deny–Deliver–Defend) + MDMP
 """
 
-# -------------------------
-# OpenAI Client
-# -------------------------
-client = None
-try:
-    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-except Exception as e:
-    print("[OpenAI] client init error:", e)
-    client = None
-
-# -------------------------
-# Knowledge Base
-# -------------------------
-def read_all_files(folder="knowledge_base"):
-    files_text = {}
-    p = Path(folder)
-    if not p.exists():
-        print(f"[KB] folder {folder} missing")
-        return files_text
-    for f in sorted(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")
-
-# -------------------------
-# Priority PDFs
-# -------------------------
-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"
-]
-
-# -------------------------
-# PARA SF Priority PDFs
-# -------------------------
-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"
-]
-
-# -------------------------
-# Reorder so priority PDFs appear first (if present)
-# -------------------------
-ordered_files = {}
-for p in PRIORITY_PDFS:
-    for k in list(FILES_TEXT.keys()):
-        if k.lower() == p.lower():
-            ordered_files[k] = FILES_TEXT.pop(k)
-            break
-for k, v in FILES_TEXT.items():
-    ordered_files[k] = v
-FILES_TEXT = ordered_files
-
-# -------------------------
-# KB Index (naive chunking & query)
-# -------------------------
-class KBIndex:
-    def __init__(self, chunk_size=1200):
-        self.docs = {}
-        self.chunk_size = chunk_size
-
-    def build_from_files(self, files_text):
-        self.docs = {}
-        for fn, txt in files_text.items():
-            if not txt:
-                continue
-            chunks = []
-            for i in range(0, len(txt), self.chunk_size):
-                chunks.append(txt[i:i+self.chunk_size])
-            self.docs[fn] = chunks
-
-    def query(self, q, top_k=3):
-        ql = q.lower().strip()
-        results = []
-        if not ql:
-            return results
-        for fn, chunks in self.docs.items():
-            best = []
-            for ch in chunks:
-                if ql in ch.lower():
-                    best.append((fn, ch[:800]))
-            results.extend(best)
-        # return first top_k unique filenames/chunks
-        seen = set()
-        out = []
-        for fn, ch in results:
-            if (fn, ch) not in seen:
-                out.append((fn, ch))
-                seen.add((fn,ch))
-            if len(out) >= top_k:
-                break
-        return out
-
-KB_INDEX = KBIndex()
-KB_INDEX.build_from_files(FILES_TEXT)
-
-print("[KB] Indexed files (priority first):")
-for f in FILES_TEXT.keys():
-    print(" -", f)
-print("[KB] Total chunks indexed:", sum(len(v) for v in KB_INDEX.docs.values()))
-
-# -------------------------
-# Operational Command — Template
-# -------------------------
-def operational_command_prompt(answers_map, category):
-    user_text = "\n".join(f"{k}: {v}" for k, v in answers_map.items() if str(v).strip())
-    return [
-        {"role": "system", "content": SYSTEM_SAFE},
-        {"role": "user", "content": f"""
-You are to prepare a structured, advisory-only report.
-
-Category: {category}
-
-Inputs:
-{user_text}
-
-Knowledge base excerpts (if any) must be considered.
-
-Report must include:
-- Executive Summary (2-4 lines)
-- Threat Assessment (administrative & doctrinal)
-- Course of Action (doctrinal, admin, advisory; non-actionable)
-- Intelligence Summary (sources & KB citations)
-- Administrative Remediations (prioritized)
-Please clearly cite KB filenames used (filename::chunk indicator).
-        """}
-    ]
-
-# -------------------------
-# Standard / Enhanced Questions
-# -------------------------
-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, semi-urban, jungle, hilly, rural)?"
-]
-
-ENH_SECTION_A = [
-    "Does the Bn have separate Ops planning and Int sections?",
-    "Does the Unit have an intelligence SOP / COA template?",
-    "Does the unit have a reconnaissance & surveillance plan?",
-    "Does the unit have Force Protection SOP and Threat Levels?",
-    "Does the unit have intelligence projection capability (forward nodes)?"
-]
-
-ENH_SECTION_B = [
-    "Is there a vulnerability analysis tool for the unit?",
-    "Does the unit employ randomness in movement and tasks?",
-    "Is there a source vetting / CI system in place?",
-    "Does the unit treat intelligence as doctrine or just data?",
-    "Does the unit use CI in vulnerability & operational reviews?"
-]
-
-ENH_SECTION_C = [
-    "Are intelligence personnel embedded in routine ops?",
-    "Am I thinking of the Threat or the CO's Situational Awareness?",
-    "What is my intent as a staff planning element?",
-    "Do I detect, deter, deny, deliver, or destroy (5D options)?",
-    "Do external MI assets conform to the 5D system?",
-    "Have I made a vulnerability assessment (Deter/Deny)?",
-    "How do I account for Force Protection based on gaps?",
-    "Do we attack threat SA, freedom of movement, tactics, or local support?",
-    "Is operation Deliberate or Quick and do I have projected int assets?",
-    "Do I clearly distinguish Advance Warn, Surprise and Situational Awareness?"
-]
-
-# -------------------------
-# PARA SF Questions (50 real concise Qs)
-# -------------------------
-PARA_QUESTIONS_50 = [
-    "Exact location (grid / place) of sighting?",
-    "Date and time of first observation?",
-    "Direction of enemy approach?",
-    "Estimated number of personnel?",
-    "Observed leader(s) or commanders?",
-    "Enemy weapons observed (small arms, crew-served)?",
-    "Presence of vehicles (type / count)?",
-    "Signs of explosives or IED activity?",
-    "Observed rates of movement (stationary / moving)?",
-    "Formation or dispersion (tight / spread)?",
-    "Use of local population for support?",
-    "Local sympathizers identified (names/roles)?",
-    "Logistics / resupply indicators?",
-    "Known routes used by enemy?",
-    "Recent history of enemy attacks in area?",
-    "Patterns of life detected (timings, routines)?",
-    "Use of communications (radios, phones, signals)?",
-    "Evidence of foreign or external support?",
-    "Sanctuary / hideouts identified?",
-    "Medical support observed (casualty handling)?",
-    "Use of deception or camouflage?",
-    "Counter-surveillance signs noted?",
-    "Electronic signature / unusual transmissions?",
-    "Use of snipers or precision shooters?",
-    "Use of indirect fires or mortars observed?",
-    "Known HVTs (leadership, infrastructure) in area?",
-    "Enemy morale indicators (behavior, chatter)?",
-    "Training level (disciplined / ad hoc)?",
-    "Use of booby traps or delayed attacks?",
-    "Any previous successful ambushes nearby?",
-    "Civilian movement patterns near enemy locations?",
-    "Sources of local intel for friendly forces?",
-    "Credibility of available human sources?",
-    "Any known double-agents or compromised sources?",
-    "Physical terrain features exploited by enemy?",
-    "Weather impacts on enemy movement?",
-    "Recent arrests/detentions related to enemy?",
-    "Any legal or jurisdictional constraints locally?",
-    "Evidence of command-and-control nodes?",
-    "Access to fuel/facility caches?",
-    "Enemy ability to disperse quickly?",
-    "Likelihood of reinforcement from nearby areas?",
-    "Time-to-redeploy for friendly quick reaction forces?",
-    "Observations on enemy sustainment posture?",
-    "Any indicators of planned escalation?",
-    "Local civilian sentiment (hostile/neutral/supportive)?",
-    "Possible safe-exit routes for friendly forces?",
-    "Any cultural or legal sensitivities to consider?",
-    "Any open-source / social media indicators?",
-    "Urgency rating (low / med / high) from observer field notes?"
-]
-
-# -------------------------
-# PARA SF Precautions / Protective Measures (40 items)
-# -------------------------
-PARA_PRECAUTIONS_40 = [
-    "Maintain strict radio burst discipline and short transmissions",
-    "Use alternate communication paths and pre-planned authentication",
-    "Document and register all human sources with CI vetting",
-    "Establish secure, auditable intelligence logs",
-    "Define and rehearse contingency exfiltration routes",
-    "Maintain camouflage and concealment SOPs for observation posts",
-    "Rotate observation posts and R&S teams to avoid predictability",
-    "Implement randomized foot and vehicle movement schedules",
-    "Limit use of identified local infrastructure to reduce signature",
-    "Use layered reporting with secondary confirmation requirement",
-    "Pre-authorize administrative response windows to reduce delay",
-    "Audit base layout and relocate critical assets from perimeter",
-    "Maintain medical evacuation planning and casualty drills",
-    "Ensure secure caches for critical supplies and spares",
-    "Institute source validation and cross-source corroboration",
-    "Use non-attributable liaison methods with local police/DEA",
-    "Formalize SOP for evidence handling and chain-of-custody",
-    "Maintain a log of all civilian interactions and transactions",
-    "Conduct red-team administrative audits quarterly",
-    "Maintain a vulnerability register and prioritized fixes",
-    "Limit exposure of leadership movements via need-to-know",
-    "Implement force protection route checklists before movement",
-    "Deploy observation posts with concealment and escape plans",
-    "Mandate brief, formatted SITREPs with required fields",
-    "Establish covert Forward Tactical C2 nodes (administrative only)",
-    "Use document-based debrief templates to capture lessons",
-    "Set up area role cards and single-point contacts per sector",
-    "Institute secure storage for source identity and vetting info",
-    "Limit public posting of unit schedules and training events",
-    "Use liaison with local law enforcement for non-operational support",
-    "Schedule regular doctrine & SOP training sessions",
-    "Maintain an audit trail for all intelligence product changes",
-    "Set thresholds for escalation to higher HQ (administrative)",
-    "Maintain alternate rendezvous points and safe houses",
-    "Ensure all unit members have basic fieldcraft refresher training",
-    "Plan periodic concealment and movement drills (administrative)",
-    "Maintain a simple, unclassified index of likely HVT indicators",
-    "Ensure information security (passwords, devices) audits quarterly",
-    "Establish a schedule for reviewing and updating SOPs"
+import os, json, glob, concurrent.futures
+from datetime import datetime
+from docx import Document
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+import gradio as gr
+import openai
+
+# ---------- CONFIG ----------
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    raise ValueError("OPENAI_API_KEY missing in environment secrets.")
+openai.api_key = OPENAI_API_KEY
+
+INTEL_TECHNIQUES = [
+    "HUMINT","SIGINT","IMINT","OSINT","MASINT","COMINT","ELINT","TECHINT",
+    "FINT","SOCMINT","GEOINT","ALL‑SOURCE INTELLIGENCE","CRISIS INTELLIGENCE",
+    "COUNTERINTELLIGENCE","RED TEAMING","BLUE TEAMING",
+    "CTRIP Analysis","SALUT Analysis","Decision Trees",
+    "Bayesian Reasoning","Network Influence Mapping"
 ]
 
-# -------------------------
-# Report Generators (KB-first, then fallback to OpenAI SF doctrine but definitely fetch SF from army sources compatible with inputs)
-# -------------------------
-def call_chat_api_system_user(messages, max_tokens=800, model="gpt-4o-mini"):
-    if client is None:
-        raise RuntimeError("OpenAI client not available.")
-    resp = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens)
-    try:
-        return resp.choices[0].message.content
-    except Exception:
-        return resp.choices[0].message.content
-
-def generate_report_with_kb(answers_map, category, top_k=3):
-    # Build KB hits per question (lens)
-    kb_hits = []
-    for q, a in answers_map.items():
-        query = (str(a).strip() or q)
-        hits = KB_INDEX.query(query, top_k=top_k)
-        kb_hits.extend(hits)
-    # Compose prompt
-    excerpt_text = ""
-    if kb_hits:
-        seen = set()
-        for fn, txt in kb_hits:
-            key = f"{fn}"
-            if key not in seen:
-                excerpt_text += f"\n--- {fn} ---\n{txt[:1200]}\n"
-                seen.add(key)
-    # Build messages
-    messages = operational_command_prompt(answers_map, category)
-    if excerpt_text:
-        messages[1]["content"] += f"\nKnowledge Base excerpts (priority applied):\n{excerpt_text}\n"
-    else:
-        # Indicate we'll fallback to SF doctrine
-        messages[1]["content"] += "\n[No KB excerpts found for these inputs; assistant may fallback to authoritative SF doctrine for doctrinal guidance.]\n"
-    # Call model
-    try:
-        out = call_chat_api_system_user(messages, max_tokens=900)
-        return out.strip()
-    except Exception as e:
-        # Fallback deterministic admin report
-        lines = ["[FALLBACK ACTIONABLE REPORT — AI unavailable]\n"]
-        lines.append("Executive Summary: Administrative findings based on inputs.\n")
-        lines.append("Key Issues:")
-        for q, a in answers_map.items():
-            lines.append(f"- {q}: {'[no answer]' if not str(a).strip() else str(a)}")
-        lines.append("\nAdministrative Recommendations (deterministic):")
-        lines.append("- Ensure SITREP templates have mandatory fields (time, geo, observer).")
-        lines.append("- Institute source vetting and require secondary confirmation of local reports.")
-        lines.append("- Conduct a quarterly vulnerability audit and publish remediations.")
-        lines.append(f"\nError: {e}")
-        return "\n".join(lines)
-
-# PARA SF runner (KB first + SF doctrine fallback)
-def para_sf_inference_runner(selected_files, pasted_notes, answers_map):
-    # Force priority list: if selected_files provided use them, else use SF_PRIORITY_PDFS present in KB
-    selected = selected_files or [p for p in SF_PRIORITY_PDFS if p in FILES_TEXT]
-    kb_hits = []
-    # pull KB excerpts only from selected first, then general KB if needed
-    for q, a in answers_map.items():
-        query = (str(a).strip() or q)
-        # search within selected files first
-        for fn in selected:
-            if fn in KB_INDEX.docs:
-                for ch in KB_INDEX.docs[fn]:
-                    if query.lower() in ch.lower():
-                        kb_hits.append((fn, ch[:1200]))
-                        break
-        # if not found in selected, do general query
-        if not any(fn == k for k,_ in kb_hits):
-            hits = KB_INDEX.query(query, top_k=1)
-            if hits:
-                kb_hits.extend(hits)
-    excerpt_text = ""
-    if kb_hits:
-        seen = set()
-        for fn, txt in kb_hits:
-            if fn not in seen:
-                excerpt_text += f"\n--- {fn} ---\n{txt[:1200]}\n"
-                seen.add(fn)
-    # Compose user text
-    user_text = "\n".join(f"{k}: {v}" for k, v in answers_map.items() if str(v).strip())
-    messages = [
-        {"role":"system","content":SYSTEM_SAFE},
-        {"role":"user","content":f"""
-Prepare a NON-ACTIONABLE PARA SF advisory using the 5D lens and doctrine.
-Inputs:
-{user_text}
-
-Fieldcraft notes:
-{pasted_notes}
-
-Selected SF KB files (priority): {selected}
-
-Knowledge Base excerpts (if any):
-{excerpt_text}
-
-Output required:
-- Executive Summary (2-4 lines)
-- Doctrinal Course of Action (administrative / doctrinal guidance only)
-- Threat Assessment (high-level, non-actionable)
-- Intelligence Summary (sources cited)
-- PARA SF Precautions & Protective Measures (administrative list)
-Cite KB filenames used.
-"""}]
+# ---------- KNOWLEDGE‑BASE LOADING ----------
+def load_kb_snippets():
+    kb_text = ""
+    for f in glob.glob("knowledge_base/*"):
+        name = os.path.basename(f)
+        if any(k in name for k in ["5d","5D","mdmp","MDMP","jsonl","SOP","coa"]):
+            try:
+                with open(f, "r", encoding="utf‑8", errors="ignore") as fh:
+                    kb_text += f"\n--- {name} ---\n{fh.read()}\n"
+            except Exception:
+                pass
+    return kb_text[:20000]  # safety cap
+
+# ---------- CORE ANALYSIS ----------
+def analyze_with_technique(tech, problem, kb_text):
+    prompt = f"""
+Training context: defensive / educational only.
+
+Using the {tech} discipline, apply the 5D framework (Detect, Deter, Deny, Deliver, Defend)
+and MDMP reasoning to analyse the following situation:
+
+{problem}
+
+Reference knowledge (for orientation only):
+{kb_text}
+
+Return JSON:
+{{
+ "technique": "{tech}",
+ "findings": "...",
+ "5D": {{
+   "Detect": "...", "Deter": "...", "Deny": "...", "Deliver": "...", "Defend": "..."
+ }},
+ "recommended_actions": ["...", "..."],
+ "confidence": {{"level":"High|Medium|Low","reason":"..."}}
+}}
+"""
     try:
-        out = call_chat_api_system_user(messages, max_tokens=1000)
-        return out.strip()
+        resp = openai.ChatCompletion.create(
+            model="gpt-4-turbo",
+            messages=[
+                {"role":"system","content":"You are a senior military intelligence instructor. Provide non‑kinetic, training‑safe analysis."},
+                {"role":"user","content":prompt}
+            ],
+            temperature=0.5,
+            max_tokens=600
+        )
+        txt = resp["choices"][0]["message"]["content"].strip()
+        try:
+            data = json.loads(txt)
+        except:
+            data = {"technique":tech,"findings":txt,"5D":{},"recommended_actions":[],
+                    "confidence":{"level":"Unknown","reason":"Text only"}}
+        return data
     except Exception as e:
-        # Fallback deterministic extraction of precautions
-        lines = [f"[FALLBACK ACTIONABLE PARA SF REPORT — AI unavailable: {e}]\n"]
-        lines.append("Executive Summary: See fieldcraft and KB for details.\n")
-        lines.append("Top observed inputs (sample):")
-        cnt = 0
-        for k,v in answers_map.items():
-            if v and cnt < 8:
-                lines.append(f"- {k}: {v}")
-                cnt += 1
-        lines.append("\nPrecautions (sample deterministic):")
-        for i, itm in enumerate(PARA_PRECAUTIONS_40[:12], start=1):
-            lines.append(f"{i}. {itm} — Admin remediation: document & audit.")
-        return "\n".join(lines)
-
-# -------------------------
-# Gradio UI
-# -------------------------
-with gr.Blocks() as demo:
-    gr.HTML(f'<img src="{BANNER_URL}" width="100%">')
-    gr.Markdown("# Kashmir AOR Action Plan — Battle Planner")
-    gr.Markdown("⚠️ **ACTIONABLE — Doctrinal / Administrative Tactical guidance only.**")
-
-    # ---- Standard Tab ----
-    with gr.Tab("Standard"):
-        std_inputs = [gr.Textbox(label=q, lines=1) for q in STD_QUESTIONS]
-        std_button = gr.Button("Generate Standard Advisory")
-        std_output = gr.Textbox(label="Standard Advisory Report (sanitized)", lines=28)
-        def std_runner(*answers):
-            amap = dict(zip(STD_QUESTIONS, answers))
-            return generate_report_with_kb(amap, "Standard Threat Advisory")
-        std_button.click(std_runner, inputs=std_inputs, outputs=std_output)
-
-    # ---- Enhanced Tab ----
-    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_input = gr.Textbox(label="Gate Question / Final Note", lines=1)
-        enh_button = gr.Button("Generate Enhanced Advisory")
-        enh_output = gr.Textbox(label="Enhanced Advisory Report (sanitized)", lines=28)
-        def enh_runner(*answers):
-            la, lb, lc = len(ENH_SECTION_A), len(ENH_SECTION_B), len(ENH_SECTION_C)
-            vals = list(answers)
-            # map A/B/C into a single answers_map for generation
-            amap = {}
-            for i, q in enumerate(ENH_SECTION_A):
-                amap[q] = vals[i] if i < len(vals) else ""
-            for j, q in enumerate(ENH_SECTION_B):
-                idx = la + j
-                amap[q] = vals[idx] if idx < len(vals) else ""
-            for k, q in enumerate(ENH_SECTION_C):
-                idx = la + lb + k
-                amap[q] = vals[idx] if idx < len(vals) else ""
-            gate = vals[-1] if vals else ""
-            # include gate as special entry
-            if gate:
-                amap["Gate Assessment"] = gate
-            return generate_report_with_kb(amap, "Enhanced 5D Advisory")
-        enh_button.click(enh_runner, inputs=a_inputs+b_inputs+c_inputs+[gate_input], outputs=enh_output)
-
-    # ---- Threat Readiness Tab ----
-    with gr.Tab("Threat Readiness"):
-        gr.Markdown("## Threat Readiness — Color-coded Commander Brief (administrative)")
-        threat_button = gr.Button("Evaluate Threat Readiness")
-        threat_output = gr.Textbox(label="Threat Readiness & Diagnostics (sanitized)", lines=28)
-        def threat_runner():
-            lines = []
-            lines.append("### Threat Readiness Level (Color-coded) — Administrative Brief")
-            lines.append("- 🔴 RED (<50%): Significant administrative vulnerabilities. Prioritize SOP, CI, audits.")
-            lines.append("- 🟠 ORANGE (50–69%): Moderate gaps; schedule doctrinal reviews and R&S validation.")
-            lines.append("- 🔵 BLUE (70–84%): Minor gaps; plan targeted training and audits.")
-            lines.append("- 🟢 GREEN (85–100%): Strong readiness; maintain periodic reviews.\n")
-            lines.append("Commander’s Guide: Use remedial actions focused on doctrine, SOP updates, source vetting and audits. This brief is non-actionable.")
-            return "\n".join(lines)
-        threat_button.click(threat_runner, inputs=[], outputs=threat_output)
-
-    # ---- PARA SF Tab ----
-    with gr.Tab("PARA SF (Two Reports)"):
-        gr.Markdown("## PARA SF — Two Separate Administrative Advisories (Non-Actionable)")
-        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 (optional)")
-        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 (sanitized)", lines=28)
-        para_prec_out = gr.Textbox(label="PARA SF Precautions & Protective Measures (sanitized)", lines=28)
-
-        def para_coa_runner(*all_inputs):
-            # last two inputs are pasted notes and file selector
-            answers = list(all_inputs[:-2])
-            pasted = all_inputs[-2] or ""
-            selected = all_inputs[-1] or []
-            amap = dict(zip(PARA_QUESTIONS_50, answers))
-            return para_sf_inference_runner(selected, pasted, amap)
-
-        def para_prec_runner(*all_inputs):
-            answers = list(all_inputs[:-2])
-            pasted = all_inputs[-2] or ""
-            selected = all_inputs[-1] or []
-            amap = dict(zip(PARA_QUESTIONS_50, answers))
-            # We'll run the same inference but return the precautions section — model is asked to include it
-            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)
-
-# -------------------------
-# Launch
-# -------------------------
-if __name__ == "__main__":
-    demo.launch(auth=("ops", "opsint5820"))
-
+        return {"technique":tech,"findings":f"Analysis failed: {e}","5D":{},
+                "recommended_actions":[],"confidence":{"level":"Error","reason":str(e)}}
+
+# ---------- DOCX REPORT ----------
+def build_docx(analyses):
+    os.makedirs("reports", exist_ok=True)
+    fname = f"reports/ArmyIntel_5D_MDMP_Report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
+    doc = Document()
+    h = doc.add_heading("INTELLIGENCE ANALYSIS – INTELLIGENCE WARFARE 5D MDMP TRAINING REPORT",0)
+    h.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+    doc.add_paragraph(f"Generated on {datetime.now():%d %b %Y %H:%M:%S}", style="Caption")
+    doc.add_paragraph("—"*30)
+
+    for i,a in enumerate(analyses,1):
+        doc.add_heading(f"{i}. {a.get('technique','Unknown')}", level=1)
+        doc.add_paragraph(a.get("findings","No findings."))
+
+        doc.add_heading("5D Analysis", level=2)
+        for d in ["Detect","Deter","Deny","Deliver","Defend"]:
+            doc.add_paragraph(f"• {d}: {a.get('5D',{}).get(d,'')}", style="List Bullet")
+
+        doc.add_heading("Recommended Actions", level=2)
+        if a.get("recommended_actions"):
+            for r in a["recommended_actions"]:
+                doc.add_paragraph(f"• {r}", style="List Bullet")
+        else:
+            doc.add_paragraph("• None / pending analysis")
+
+        c = a.get("confidence",{})
+        doc.add_paragraph(f"Confidence: {c.get('level','Unknown')} – {c.get('reason','')}")
+        doc.add_paragraph(" ")
+
+    doc.add_heading("MDMP Summary", level=1)
+    doc.add_paragraph(
+        "1. Problem identification → 2. Intelligence gathering → 3. COA development → "
+        "4. COA analysis → 5. Decision & execution (Training Simulation only)."
+    )
+    doc.save(fname)
+    return fname
+
+# ---------- MAIN ENGINE ----------
+def run_full_analysis(problem):
+    kb_text = load_kb_snippets()
+    analyses=[]
+    with concurrent.futures.ThreadPoolExecutor(max_workers=6) as pool:
+        futures={pool.submit(analyze_with_technique,t,problem,kb_text):t for t in INTEL_TECHNIQUES}
+        for f in concurrent.futures.as_completed(futures):
+            analyses.append(f.result())
+    return build_docx(analyses)
+
+# ---------- GRADIO UI ----------
+def start_analysis(problem):
+    if not problem.strip():
+        problem="Training scenario: suspected hostile surveillance around forward base; assess defensive posture."
+    path=run_full_analysis(problem)
+    return path
+
+demo=gr.Interface(
+    fn=start_analysis,
+    inputs=gr.Textbox(label="Enter Training / Defensive Problem", lines=8),
+    outputs=gr.File(label="Download Training Intelligence Report"),
+    title="ARMYINTEL 5D + MDMP Training Engine",
+    description="Educational simulation engine for non‑kinetic intelligence analysis using 21 techniques + 5D + MDMP."
+)
+
+if __name__=="__main__":
+    demo.launch()