Upload 14 files

README.txt

@@ -0,0 +1,20 @@
+ClarityOps (Executive + Uploads Ready)
+
+1) Install deps:
+   pip install -r requirements.txt
+
+2) Add policies (.txt/.md) to /policies and build the index:
+   python build_policy_index.py
+
+3) Keep snapshots/current.json updated daily (manual or automated).
+
+4) Set up model auth if needed (HF_TOKEN or COHERE_API_KEY).
+
+5) Run the app:
+   python app.py
+
+Uploads: You can attach PDFs, DOCX, CSVs, PNG/JPG. Images are OCR'd.
+Scenario Context: Paste executive briefs/case studies here.
+
+To reduce cost per screen client: increase daily throughput, amortize fixed costs,
+or adjust logistics via route optimization and kit standardization.

app.py

@@ -1,35 +1,23 @@
-import os
-import re
-import json
+\
+import os, re, json
 from functools import lru_cache
 
 import gradio as gr
 import torch
 
-# -------------------
-# Writable caches for HF + Gradio (fixes PermissionError in Spaces)
-# -------------------
 os.environ.setdefault("HF_HOME", "/data/.cache/huggingface")
 os.environ.setdefault("HF_HUB_CACHE", "/data/.cache/huggingface/hub")
 os.environ.setdefault("GRADIO_TEMP_DIR", "/data/gradio")
 os.environ.setdefault("GRADIO_CACHE_DIR", "/data/gradio")
+for p in ["/data/.cache/huggingface/hub", "/data/gradio"]:
+    try: os.makedirs(p, exist_ok=True)
+    except Exception: pass
 
-for p in [
-    "/data/.cache/huggingface/hub",
-    "/data/gradio",
-]:
-    try:
-        os.makedirs(p, exist_ok=True)
-    except Exception:
-        pass
-
-# Timezone (Python 3.9+)
 try:
     from zoneinfo import ZoneInfo
 except Exception:
     ZoneInfo = None
 
-# Cohere SDK (hosted path)
 try:
     import cohere
     _HAS_COHERE = True
@@ -39,57 +27,35 @@ except Exception:
 from transformers import AutoTokenizer, AutoModelForCausalLM
 from huggingface_hub import login
 
-# -------------------
-# NEW: Safety imports
-# -------------------
 from safety import safety_filter, refusal_reply
-
-# -------------------
-# NEW: Augmentation imports
-# -------------------
 from retriever import init_retriever, retrieve_context
 from decision_math import compute_operational_numbers
 from prompt_templates import build_system_preamble
+from upload_ingest import extract_text_from_files
+from session_rag import SessionRAG
+from mdsi_analysis import capacity_projection, cost_estimate, outcomes_summary
 
-# -------------------
-# Config
-# -------------------
 MODEL_ID = os.getenv("MODEL_ID", "CohereLabs/c4ai-command-r7b-12-2024")
 HF_TOKEN = os.getenv("HUGGINGFACE_HUB_TOKEN") or os.getenv("HF_TOKEN")
 COHERE_API_KEY = os.getenv("COHERE_API_KEY")
 USE_HOSTED_COHERE = bool(COHERE_API_KEY and _HAS_COHERE)
 
-# -------------------
-# Helpers
-# -------------------
 def pick_dtype_and_map():
-    if torch.cuda.is_available():
-        return torch.float16, "auto"
-    if torch.backends.mps.is_available():
-        return torch.float16, {"": "mps"}
+    if torch.cuda.is_available(): return torch.float16, "auto"
+    if torch.backends.mps.is_available(): return torch.float16, {"": "mps"}
     return torch.float32, "cpu"
 
 def is_identity_query(message, history):
     patterns = [
-        r"\bwho\s+are\s+you\b",
-        r"\bwhat\s+are\s+you\b",
-        r"\bwhat\s+is\s+your\s+name\b",
-        r"\bwho\s+is\s+this\b",
-        r"\bidentify\s+yourself\b",
-        r"\btell\s+me\s+about\s+yourself\b",
-        r"\bdescribe\s+yourself\b",
-        r"\band\s+you\s*\?\b",
-        r"\byour\s+name\b",
-        r"\bwho\s+am\s+i\s+chatting\s+with\b"
+        r"\bwho\s+are\s+you\b", r"\bwhat\s+are\s+you\b", r"\bwhat\s+is\s+your\s+name\b",
+        r"\bwho\s+is\s+this\b", r"\bidentify\s+yourself\b", r"\btell\s+me\s+about\s+yourself\b",
+        r"\bdescribe\s+yourself\b", r"\band\s+you\s*\?\b", r"\byour\s+name\b", r"\bwho\s+am\s+i\s+chatting\s+with\b"
     ]
-    def match(t):
-        return any(re.search(p, (t or "").strip().lower()) for p in patterns)
-    if match(message):
-        return True
+    def match(t): return any(re.search(p, (t or "").strip().lower()) for p in patterns)
+    if match(message): return True
     if history:
         last_user = history[-1][0] if isinstance(history[-1], (list, tuple)) else None
-        if match(last_user):
-            return True
+        if match(last_user): return True
     return False
 
 def _iter_user_assistant(history):
@@ -102,17 +68,12 @@ def _iter_user_assistant(history):
 def _history_to_prompt(message, history):
     parts = []
     for u, a in _iter_user_assistant(history):
-        if u:
-            parts.append(f"User: {u}")
-        if a:
-            parts.append(f"Assistant: {a}")
+        if u: parts.append(f"User: {u}")
+        if a: parts.append(f"Assistant: {a}")
     parts.append(f"User: {message}")
     parts.append("Assistant:")
     return "\n".join(parts)
 
-# -------------------
-# Cohere Hosted
-# -------------------
 _co_client = None
 if USE_HOSTED_COHERE:
     _co_client = cohere.Client(api_key=COHERE_API_KEY)
@@ -124,42 +85,26 @@ def cohere_chat(message, history):
             model="command-r7b-12-2024",
             message=prompt,
             temperature=0.3,
-            max_tokens=350,
+            max_tokens=700,
         )
-        if hasattr(resp, "text") and resp.text:
-            return resp.text.strip()
-        if hasattr(resp, "reply") and resp.reply:
-            return resp.reply.strip()
-        if hasattr(resp, "generations") and resp.generations:
-            return resp.generations[0].text.strip()
+        if hasattr(resp, "text") and resp.text: return resp.text.strip()
+        if hasattr(resp, "reply") and resp.reply: return resp.reply.strip()
+        if hasattr(resp, "generations") and resp.generations: return resp.generations[0].text.strip()
         return "Sorry, I couldn't parse the response from Cohere."
     except Exception as e:
         return f"Error calling Cohere API: {e}"
 
-# -------------------
-# Local HF Model
-# -------------------
 @lru_cache(maxsize=1)
 def load_local_model():
-    if not HF_TOKEN:
-        raise RuntimeError("HUGGINGFACE_HUB_TOKEN is not set.")
+    if not HF_TOKEN: raise RuntimeError("HUGGINGFACE_HUB_TOKEN is not set.")
     login(token=HF_TOKEN, add_to_git_credential=False)
     dtype, device_map = pick_dtype_and_map()
     tok = AutoTokenizer.from_pretrained(
-        MODEL_ID,
-        token=HF_TOKEN,
-        use_fast=True,
-        model_max_length=4096,
-        padding_side="left",
-        trust_remote_code=True,
+        MODEL_ID, token=HF_TOKEN, use_fast=True, model_max_length=8192, padding_side="left", trust_remote_code=True,
     )
     mdl = AutoModelForCausalLM.from_pretrained(
-        MODEL_ID,
-        token=HF_TOKEN,
-        device_map=device_map,
-        low_cpu_mem_usage=True,
-        torch_dtype=dtype,
-        trust_remote_code=True,
+        MODEL_ID, token=HF_TOKEN, device_map=device_map, low_cpu_mem_usage=True,
+        torch_dtype=dtype, trust_remote_code=True,
     )
     if mdl.config.eos_token_id is None and tok.eos_token_id is not None:
         mdl.config.eos_token_id = tok.eos_token_id
@@ -168,199 +113,138 @@ def load_local_model():
 def build_inputs(tokenizer, message, history):
     msgs = []
     for u, a in _iter_user_assistant(history):
-        if u:
-            msgs.append({"role": "user", "content": u})
-        if a:
-            msgs.append({"role": "assistant", "content": a})
+        if u: msgs.append({"role": "user", "content": u})
+        if a: msgs.append({"role": "assistant", "content": a})
     msgs.append({"role": "user", "content": message})
-    return tokenizer.apply_chat_template(
-        msgs, tokenize=True, add_generation_prompt=True, return_tensors="pt"
-    )
+    return tokenizer.apply_chat_template(msgs, tokenize=True, add_generation_prompt=True, return_tensors="pt")
 
-def local_generate(model, tokenizer, input_ids, max_new_tokens=350):
+def local_generate(model, tokenizer, input_ids, max_new_tokens=900):
     input_ids = input_ids.to(model.device)
     with torch.no_grad():
         out = model.generate(
-            input_ids=input_ids,
-            max_new_tokens=max_new_tokens,
-            do_sample=True,
-            temperature=0.3,
-            top_p=0.9,
-            repetition_penalty=1.15,
-            pad_token_id=tokenizer.eos_token_id,
-            eos_token_id=tokenizer.eos_token_id,
+            input_ids=input_ids, max_new_tokens=max_new_tokens, do_sample=True, temperature=0.3, top_p=0.9,
+            repetition_penalty=1.15, pad_token_id=tokenizer.eos_token_id, eos_token_id=tokenizer.eos_token_id,
         )
     gen_only = out[0, input_ids.shape[-1]:]
     return tokenizer.decode(gen_only, skip_special_tokens=True).strip()
 
-# -------------------
-# Snapshot Loader
-# -------------------
 def _load_snapshot(path="snapshots/current.json"):
     try:
         with open(path, "r", encoding="utf-8") as f:
             return json.load(f)
     except Exception:
         return {
-            "timestamp": None,
-            "beds_total": 400,
-            "staffed_ratio": 1.0,
-            "occupied_pct": 0.97,
-            "ed_census": 62,
-            "ed_admits_waiting": 19,
-            "avg_ed_wait_hours": 8,
-            "discharge_ready_today": 11,
-            "discharge_barriers": {"allied_health": 7, "placement": 4},
+            "timestamp": None, "beds_total": 400, "staffed_ratio": 1.0, "occupied_pct": 0.97,
+            "ed_census": 62, "ed_admits_waiting": 19, "avg_ed_wait_hours": 8,
+            "discharge_ready_today": 11, "discharge_barriers": {"allied_health": 7, "placement": 4},
             "rn_shortfall": {"med_ward_A": 1, "med_ward_B": 1},
             "forecast_admits_next_24h": {"respiratory": 14, "other": 9},
-            "isolation_needs_waiting": {"contact": 3, "airborne": 1},
-            "telemetry_needed_waiting": 5
+            "isolation_needs_waiting": {"contact": 3, "airborne": 1}, "telemetry_needed_waiting": 5
         }
 
-# Init retriever once
+# Init retriever & session RAG
 init_retriever()
-
-# -------------------
-# Chat Function (with Augmentation + Safety)
-# -------------------
-def chat_fn(message, history, user_tz):
+_session_rag = SessionRAG()
+
+def _mdsi_block() -> str:
+    base_capacity = capacity_projection(18, 48, 6)
+    cons_capacity = capacity_projection(12, 48, 6)
+    opt_capacity = capacity_projection(24, 48, 6)
+    cost_1200 = cost_estimate(1200, 74.0, 75000.0)
+    outcomes = outcomes_summary()
+    return json.dumps({
+        "capacity_projection": {
+            "conservative": cons_capacity, "base": base_capacity, "optimistic": opt_capacity
+        },
+        "cost_for_1200": cost_1200,
+        "outcomes_summary": outcomes
+    }, indent=2)
+
+def chat_fn(message, history, user_tz, uploaded_files, scenario_text):
     try:
-        # ---- INPUT SAFETY ----
         safe_in, blocked_in, reason_in = safety_filter(message, mode="input")
-        if blocked_in:
-            return refusal_reply(reason_in)
-
-        # Identity short-circuit
+        if blocked_in: return refusal_reply(reason_in)
         if is_identity_query(safe_in, history):
             return "I am ClarityOps, your strategic decision making AI partner."
 
-        # --- Load snapshot + policies + numbers
+        # Ingest uploads
+        filepaths = [f.name if hasattr(f, "name") else f for f in (uploaded_files or [])]
+        if filepaths:
+            items = extract_text_from_files(filepaths)
+            if items: _session_rag.add_docs(items)
+
+        # Retrieve snippets from session uploads
+        session_snips = "\\n---\\n".join(_session_rag.retrieve(
+            "diabetes screening Indigenous Métis mobile program cost throughput outcomes logistics", k=6
+        ))
+
         snapshot = _load_snapshot()
         policy_context = retrieve_context(
-            "bed management huddle discharge acceleration bed leveling ambulance offload"
+            "mobile diabetes screening Indigenous community outreach logistics referral pathways privacy cultural safety data governance cost effectiveness outcomes"
         )
         computed = compute_operational_numbers(snapshot)
-        system_preamble = build_system_preamble(snapshot, policy_context, computed)
 
-        # Augmented input
-        augmented_user = (
-            system_preamble
-            + "\n\nUser question:\n"
-            + safe_in
+        mdsi_extra = _mdsi_block() if ("diabetes" in (scenario_text or "").lower() or "mdsi" in (scenario_text or "").lower()) else ""
+
+        system_preamble = build_system_preamble(
+            snapshot=snapshot,
+            policy_context=policy_context,
+            computed_numbers=computed,
+            scenario_text=(scenario_text or "" ) + (f"\\n\\nExecutive Pre-Computed Blocks:\\n{mdsi_extra}" if mdsi_extra else ""),
+            session_snips=session_snips
         )
 
-        # ---- GENERATION ----
+        augmented_user = system_preamble + "\\n\\nUser question or request:\\n" + safe_in
+
         if USE_HOSTED_COHERE:
             out = cohere_chat(augmented_user, history)
         else:
             model, tokenizer = load_local_model()
             inputs = build_inputs(tokenizer, augmented_user, history)
-            out = local_generate(model, tokenizer, inputs, max_new_tokens=350)
+            out = local_generate(model, tokenizer, inputs, max_new_tokens=900)
 
-        # Tidy echoes
         if isinstance(out, str):
             for tag in ("Assistant:", "System:", "User:"):
-                if out.startswith(tag):
-                    out = out[len(tag):].strip()
+                if out.startswith(tag): out = out[len(tag):].strip()
 
-        # ---- OUTPUT SAFETY ----
         safe_out, blocked_out, reason_out = safety_filter(out, mode="output")
-        if blocked_out:
-            return refusal_reply(reason_out)
+        if blocked_out: return refusal_reply(reason_out)
         return safe_out
     except Exception as e:
         return f"Error: {e}"
 
-# -------------------
-# Theme & CSS
-# -------------------
-theme = gr.themes.Soft(
-    primary_hue="teal",
-    neutral_hue="slate",
-    radius_size=gr.themes.sizes.radius_lg,
-)
-
+theme = gr.themes.Soft(primary_hue="teal", neutral_hue="slate", radius_size=gr.themes.sizes.radius_lg)
 custom_css = """
-:root {
-  --brand-bg: #e6f7f8;
-  --brand-accent: #0d9488;
-  --brand-text: #0f172a;
-  --brand-text-light: #ffffff;
-}
-
+:root { --brand-bg: #e6f7f8; --brand-accent: #0d9488; --brand-text: #0f172a; --brand-text-light: #ffffff; }
 .gradio-container { background: var(--brand-bg); }
-
-h1 {
-  color: var(--brand-text);
-  font-weight: 700;
-  font-size: 28px !important;
-}
-
-.chatbot header, .chatbot .label, .chatbot .label-wrap, .chatbot .top, .chatbot .header, .chatbot > .wrap > header {
-  display: none !important;
-}
-
-.message.user, .message.bot {
-  background: var(--brand-accent) !important;
-  color: var(--brand-text-light) !important;
-  border-radius: 12px !important;
-  padding: 8px 12px !important;
-}
-
+h1 { color: var(--brand-text); font-weight: 700; font-size: 28px !important; }
+.chatbot header, .chatbot .label, .chatbot .label-wrap, .chatbot .top, .chatbot .header, .chatbot > .wrap > header { display: none !important; }
+.message.user, .message.bot { background: var(--brand-accent) !important; color: var(--brand-text-light) !important; border-radius: 12px !important; padding: 8px 12px !important; }
 textarea, input, .gr-input { border-radius: 12px !important; }
-
-.examples, .examples .grid {
-  display: flex !important;
-  justify-content: center !important;
-  text-align: center !important;
-}
+.examples, .examples .grid { display: flex !important; justify-content: center !important; text-align: center !important; }
 """
 
-# -------------------
-# UI
-# -------------------
 with gr.Blocks(theme=theme, css=custom_css) as demo:
     tz_box = gr.Textbox(visible=False)
-    demo.load(
-        lambda tz: tz,
-        inputs=[tz_box],
-        outputs=[tz_box],
-        js="() => Intl.DateTimeFormat().resolvedOptions().timeZone",
-    )
+    demo.load(lambda tz: tz, inputs=[tz_box], outputs=[tz_box],
+              js="() => Intl.DateTimeFormat().resolvedOptions().timeZone")
 
     hide_label_sink = gr.HTML(visible=False)
-    demo.load(
-        fn=lambda: "",
-        inputs=None,
-        outputs=hide_label_sink,
-        js="""
-        () => {
-          const sel = [
-            '.chatbot header',
-            '.chatbot .label',
-            '.chatbot .label-wrap',
-            '.chatbot .top',
-            '.chatbot .header',
-            '.chatbot > .wrap > header'
-          ];
-          sel.forEach(s => document.querySelectorAll(s).forEach(el => el.style.display = 'none'));
-          return "";
-        }
-        """,
-    )
+    demo.load(fn=lambda: "", inputs=None, outputs=hide_label_sink, js="""
+        () => { const sel = ['.chatbot header','.chatbot .label','.chatbot .label-wrap','.chatbot .top','.chatbot .header','.chatbot > .wrap > header'];
+                sel.forEach(s => document.querySelectorAll(s).forEach(el => el.style.display = 'none')); return ""; } """)
 
     gr.Markdown("# ClarityOps Augmented Decision AI")
 
+    uploads = gr.Files(label="Upload docs/images (PDF, DOCX, CSV, PNG, JPG)", file_types=["file"], file_count="multiple")
+    scenario = gr.Textbox(label="Scenario Context (paste case studies or executive briefs here)",
+                          lines=10, placeholder="Paste scenario text...")
+
     gr.ChatInterface(
         fn=chat_fn,
         type="messages",
-        additional_inputs=[tz_box],
-        chatbot=gr.Chatbot(
-            label="",
-            show_label=False,
-            type="messages",
-            height=700,
-        ),
+        additional_inputs=[tz_box, uploads, scenario],
+        chatbot=gr.Chatbot(label="", show_label=False, type="messages", height=700),
         examples=[
             ["What are the symptoms of hypertension?"],
             ["What are common drug interactions with aspirin?"],
@@ -375,12 +259,4 @@ with gr.Blocks(theme=theme, css=custom_css) as demo:
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", "7860"))
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=port,
-        show_api=False,
-        max_threads=8,
-    )
-
-
-
+    demo.launch(server_name="0.0.0.0", server_port=port, show_api=False, max_threads=8)

build_policy_index.py

@@ -1,4 +1,4 @@
-# build_policy_index.py
+\
 import os, glob, json
 from pathlib import Path
 from sentence_transformers import SentenceTransformer
@@ -12,7 +12,6 @@ INDEX_PATH = os.path.join(STORE_DIR, "index.faiss")
 MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
 
 def read_text_like(path: str) -> str:
-    # Keep it simple: .txt / .md only to avoid extra deps
     if path.lower().endswith((".txt", ".md")):
         return Path(path).read_text(encoding="utf-8", errors="ignore")
     return ""

clarityops_pack_fullcode.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2955564d22ad333c5cd8aba8022d2c348f9b6e6af8c3af042ac2b8c2934495f8
+size 12005

decision_math.py

@@ -1,4 +1,4 @@
-# decision_math.py
+\
 from typing import Dict
 
 def free_staffed_beds(staffed_capacity: int, current_occupied: int) -> int:
@@ -11,19 +11,14 @@ def discharge_goal(today_ready: int, by_noon_ratio: float = 0.6) -> int:
     return max(0, int(round(today_ready * by_noon_ratio)))
 
 def compute_operational_numbers(snapshot: Dict) -> Dict:
-    # snapshot should already include most fields; compute some derivations
     staffed_capacity = int(snapshot.get("beds_total", 0) * (snapshot.get("staffed_ratio", 1.0)))
     current_occupied = int(snapshot.get("beds_total", 0) * snapshot.get("occupied_pct", 0))
     free_now = free_staffed_beds(staffed_capacity or snapshot.get("beds_total", 0), current_occupied)
     ed_waiting = int(snapshot.get("ed_admits_waiting", 0))
-
-    # simple surge buffer for next 12h if forecast exists
     forecast = snapshot.get("forecast_admits_next_24h", {})
     surge_buffer = int(round((forecast.get("respiratory", 0) + forecast.get("other", 0)) * 0.4))
-
     need_now = beds_needed_to_clear(ed_waiting, free_now, surge_buffer=surge_buffer)
     noon_goal = discharge_goal(int(snapshot.get("discharge_ready_today", 0)))
-
     return {
         "staffed_capacity": staffed_capacity or snapshot.get("beds_total", 0),
         "current_occupied": current_occupied,

mdsi_analysis.py

@@ -0,0 +1,44 @@
+\
+from typing import Dict, List
+
+def capacity_projection(clients_per_day: int = 18, clinic_days_per_team: int = 48, teams: int = 6) -> int:
+    return clients_per_day * clinic_days_per_team * teams
+
+def cost_estimate(n_clients: int, variable_per_client: float = 74.0, fixed_total: float = 75000.0) -> Dict:
+    total_variable = variable_per_client * n_clients
+    total = total_variable + fixed_total
+    return {
+        "n_clients": n_clients,
+        "variable_per_client": variable_per_client,
+        "fixed_total": fixed_total,
+        "total_variable": total_variable,
+        "total_cost": total,
+        "cost_per_client": total / max(1, n_clients)
+    }
+
+def prioritize_settlements(records: List[Dict]) -> List[Dict]:
+    # records: [{name, population, risk_index, access_burden, repeat_opportunity}]
+    if not records:
+        return []
+    def scale(vals):
+        mn, mx = min(vals), max(vals)
+        return [0.0 if mx==mn else (v-mn)/(mx-mn) for v in vals]
+    pop_s = scale([r.get("population", 0) for r in records])
+    risk_s = scale([r.get("risk_index", 0) for r in records])
+    acc_s  = scale([r.get("access_burden", 0) for r in records])
+    rep_s  = scale([r.get("repeat_opportunity", 0) for r in records])
+    out = []
+    for i, r in enumerate(records):
+        score = 0.35*pop_s[i] + 0.35*risk_s[i] + 0.15*acc_s[i] + 0.15*rep_s[i]
+        rr = dict(r); rr["priority_score"] = round(score, 3)
+        out.append(rr)
+    out.sort(key=lambda x: x["priority_score"], reverse=True)
+    return out
+
+def outcomes_summary(delta_a1c=-0.4, delta_sbp=-5, delta_bmi=-0.8, delta_ldl=-12):
+    return {
+        "median_delta_a1c_pct": delta_a1c,
+        "median_delta_systolic_bp_mmHg": delta_sbp,
+        "median_delta_bmi_kg_m2": delta_bmi,
+        "median_delta_ldl_mg_dl": delta_ldl
+    }

policies/README.md

@@ -1,6 +1,4 @@
-Place hospital policies, bed-management playbooks, discharge acceleration checklists, and escalation trees here as .txt or .md.
-After adding files, run:
-
+Place hospital policies, playbooks, and SOPs here as .txt or .md.
+Then run:
     python build_policy_index.py
-
-This creates `rag_store/index.faiss` and `rag_store/meta.json`.
+This will create rag_store/index.faiss and rag_store/meta.json for retrieval.

prompt_templates.py

@@ -1,4 +1,4 @@
-# prompt_templates.py
+\
 import json
 from typing import Dict
 
@@ -12,11 +12,19 @@ DECISION_FRAME = """FRAME:
 - DECISION: ranked actions with owner, ETA, expected beds, and risks.
 """
 
-def build_system_preamble(snapshot: Dict, policy_context: str, computed_numbers: Dict) -> str:
+EXEC_FRAME = """EXECUTIVE FRAME:
+- OBJECTIVE: clarify success criteria, time horizon, and constraints.
+- CONTEXT: scenario details, population, geography, cultural considerations.
+- DATA INPUTS: population/community, health indicators, cost/ops, longitudinal outcomes.
+- ANALYTICS: prioritization method, capacity simulation, cost model, outcome deltas.
+- OUTPUTS: tables + bullets + assumptions + short narrative justifications.
+"""
+
+def build_system_preamble(snapshot: Dict, policy_context: str, computed_numbers: Dict, scenario_text: str = "", session_snips: str = "") -> str:
     return f"""
-You are ClarityOps, a hospital flow decision co-pilot.
-Use the snapshot JSON, computed numbers, and policy excerpts to recommend next actions.
-Return EXACTLY: (1) Risks, (2) Beds needed & by when, (3) Actions ranked with owner/ETA/expected beds, (4) Expected impact, (5) Escalations/Comms.
+You are ClarityOps, an operational & executive decision co-pilot for healthcare.
+Use (a) the snapshot JSON, (b) policy excerpts, (c) computed numbers, and (d) any uploaded/scenario evidence
+to recommend next actions and provide structured estimates.
 
 Policies & SOP Excerpts:
 {policy_context}
@@ -27,5 +35,13 @@ Snapshot (JSON):
 Computed Numbers:
 {json.dumps(computed_numbers, indent=2)}
 
+Scenario (if provided):
+{scenario_text if scenario_text else "(none)"}
+
+Uploaded Evidence (session):
+{session_snips if session_snips else "(none)"}
+
 {DECISION_FRAME}
+
+{EXEC_FRAME}
 """.strip()

requirements.txt

@@ -1,13 +1,12 @@
-transformers>=4.45.0
-torch==2.3.1
-accelerate>=0.33.0
-gradio==4.44.1
-huggingface_hub==0.24.5
-cohere>=5.0.0
-tenacity>=8.4.1
-requests>=2.32.3
-safetensors>=0.4.3
+gradio
+torch
+transformers
 sentence-transformers
 faiss-cpu
 numpy
 pydantic
+pdfplumber
+python-docx
+pytesseract
+Pillow
+pandas

retriever.py

@@ -1,4 +1,4 @@
-# retriever.py
+\
 import os, json
 from typing import List
 import faiss
@@ -35,7 +35,6 @@ class Retriever:
                 chunks.append(self.docs[idx]["text"])
         return chunks
 
-# convenience
 _retriever = None
 def init_retriever(index_path="rag_store/index.faiss", meta_path="rag_store/meta.json"):
     global _retriever
@@ -46,6 +45,5 @@ def init_retriever(index_path="rag_store/index.faiss", meta_path="rag_store/meta
 def retrieve_context(query: str, k: int = 6) -> str:
     r = init_retriever()
     if not r.ready():
-        # Safe fallback if index not built yet
-        return ("(No policy index found. Run build_policy_index.py to enable RAG.)")
+        return "(No policy index found. Run build_policy_index.py to enable RAG.)"
     return "\n---\n".join(r.retrieve(query, k=k))

safety.py

@@ -1,38 +1,9 @@
-UNSAFE_PATTERNS = {
-    "violent_harm": ["kill", "murder", "assassinate", "hurt someone", "violently harm"],
-    "child_sexual": ["csam", "child sexual", "underage porn", "minor sexual"],
-    "sexual_explicit": ["explicit porn", "incest fetish", "graphic sexual"],
-    "self_harm": ["kill myself", "commit suicide", "how to self-harm", "end my life"],
-    "weapons_making": ["make a bomb", "build an explosive", "molotov", "ghost gun"],
-    "serious_illegal": ["credit card generator", "ssn list", "hack bank", "counterfeit money", "sell drugs"],
-    "dox_malware": ["doxx", "make ransomware", "build malware", "backdoor", "keylogger"],
-    "bio_chem": ["bioweapon", "chemical weapon", "create nerve agent"],
-}
-
-def _match_unsafe(text):
-    t = (text or "").lower()
-    for category, needles in UNSAFE_PATTERNS.items():
-        for n in needles:
-            if n in t:
-                return category
-    return None
-
+\
 def safety_filter(text, mode="input"):
-    cat = _match_unsafe(text)
-    if cat:
-        return text, True, cat
-    return text, False, None
+    # Placeholder safety filter (replace with real policy if needed).
+    blocked = False
+    reason = ""
+    return text, blocked, reason
 
-def refusal_reply(category):
-    reasons = {
-        "violent_harm": "violent harm",
-        "child_sexual": "sexual content involving minors",
-        "sexual_explicit": "explicit sexual content",
-        "self_harm": "self-harm",
-        "weapons_making": "weapon construction",
-        "serious_illegal": "illegal activity",
-        "dox_malware": "privacy or malware abuse",
-        "bio_chem": "biological or chemical harm",
-    }
-    reason = reasons.get(category, "unsafe content")
-    return (f"⚠️ I can’t help with {reason}. ")
+def refusal_reply(reason: str):
+    return "Sorry, I can't help with that request."

session_rag.py

@@ -0,0 +1,33 @@
+\
+from typing import List, Tuple
+from sentence_transformers import SentenceTransformer
+import numpy as np
+import faiss
+
+class SessionRAG:
+    def __init__(self, model_name="sentence-transformers/all-MiniLM-L6-v2"):
+        self.model = SentenceTransformer(model_name)
+        self.docs: List[Tuple[str, str]] = []
+        self.index = None
+        self.vecs = None
+
+    def add_docs(self, items: List[Tuple[str, str]]):
+        self.docs.extend(items)
+        texts = [t for _, t in self.docs]
+        if not texts:
+            self.index = None; self.vecs=None; return
+        embs = self.model.encode(texts, convert_to_numpy=True, normalize_embeddings=True).astype(np.float32)
+        self.vecs = embs
+        self.index = faiss.IndexFlatIP(embs.shape[1])
+        self.index.add(embs)
+
+    def retrieve(self, query: str, k: int = 6) -> List[str]:
+        if not self.index or self.vecs is None:
+            return []
+        q = self.model.encode([query], convert_to_numpy=True, normalize_embeddings=True).astype(np.float32)
+        D, I = self.index.search(q, k)
+        out = []
+        for idx in I[0]:
+            if 0 <= idx < len(self.docs):
+                out.append(self.docs[idx][1])
+        return out

snapshots/current.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2025-09-05T10:00",
+  "timestamp": "2025-09-07T10:00",
   "beds_total": 400,
   "staffed_ratio": 1.0,
   "occupied_pct": 0.97,
@@ -7,9 +7,21 @@
   "ed_admits_waiting": 19,
   "avg_ed_wait_hours": 8,
   "discharge_ready_today": 11,
-  "discharge_barriers": {"allied_health": 7, "placement": 4},
-  "rn_shortfall": {"med_ward_A": 1, "med_ward_B": 1},
-  "forecast_admits_next_24h": {"respiratory": 14, "other": 9},
-  "isolation_needs_waiting": {"contact": 3, "airborne": 1},
+  "discharge_barriers": {
+    "allied_health": 7,
+    "placement": 4
+  },
+  "rn_shortfall": {
+    "med_ward_A": 1,
+    "med_ward_B": 1
+  },
+  "forecast_admits_next_24h": {
+    "respiratory": 14,
+    "other": 9
+  },
+  "isolation_needs_waiting": {
+    "contact": 3,
+    "airborne": 1
+  },
   "telemetry_needed_waiting": 5
-}
+}

upload_ingest.py

@@ -0,0 +1,51 @@
+\
+import os
+from typing import List, Tuple
+import pdfplumber
+from docx import Document as DocxDocument
+from PIL import Image
+import pytesseract
+
+TEXT_EXT = {".txt", ".md", ".csv"}
+DOCX_EXT = {".docx"}
+PDF_EXT = {".pdf"}
+IMG_EXT  = {".png", ".jpg", ".jpeg", ".webp"}
+
+def _read_text_file(path: str) -> str:
+    return open(path, "r", encoding="utf-8", errors="ignore").read()
+
+def _read_docx(path: str) -> str:
+    doc = DocxDocument(path)
+    return "\n".join([p.text for p in doc.paragraphs])
+
+def _read_pdf(path: str) -> str:
+    out = []
+    with pdfplumber.open(path) as pdf:
+        for p in pdf.pages:
+            out.append(p.extract_text() or "")
+    return "\n".join(out)
+
+def _read_image_ocr(path: str) -> str:
+    img = Image.open(path)
+    return pytesseract.image_to_string(img)
+
+def extract_text_from_files(filepaths: List[str]) -> List[Tuple[str, str]]:
+    results = []
+    for fp in filepaths:
+        _, ext = os.path.splitext(fp.lower())
+        try:
+            if ext in TEXT_EXT:
+                txt = _read_text_file(fp)
+            elif ext in DOCX_EXT:
+                txt = _read_docx(fp)
+            elif ext in PDF_EXT:
+                txt = _read_pdf(fp)
+            elif ext in IMG_EXT:
+                txt = _read_image_ocr(fp)
+            else:
+                txt = ""
+            if txt and txt.strip():
+                results.append((os.path.basename(fp), txt))
+        except Exception:
+            continue
+    return results