Upload app.py

app.py

@@ -1,313 +1,736 @@
-import gradio as gr
-import torch
-import io
-import wave
-import numpy as np
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from snac import SNAC
-
-# Mock spaces module for local testing
-try:
-    import spaces
-except ImportError:
-    class SpacesMock:
-        @staticmethod
-        def GPU(func):
-            return func
-    spaces = SpacesMock()
-
-# Constants
-CODE_START_TOKEN_ID = 128257
-CODE_END_TOKEN_ID = 128258
-CODE_TOKEN_OFFSET = 128266
-SNAC_MIN_ID = 128266
-SNAC_MAX_ID = 156937
-SOH_ID = 128259
-EOH_ID = 128260
-SOA_ID = 128261
-BOS_ID = 128000
-TEXT_EOT_ID = 128009
-AUDIO_SAMPLE_RATE = 24000
-
-# Preset characters (2 realistic + 2 creative)
-PRESET_CHARACTERS = {
-    "Male American": {
-        "description": "Realistic male voice in the 20s age with a american accent. High pitch, raspy timbre, brisk pacing, neutral tone delivery at medium intensity, viral_content domain, short_form_narrator role, neutral delivery",
-        "example_text": "And of course, the so-called easy hack didn't work at all.  What a surprise. <sigh>"
-    },
-    "Female British": {
-        "description": "Realistic female voice in the 30s age with a british accent. Normal pitch, throaty timbre, conversational pacing, sarcastic tone delivery at low intensity, podcast domain, interviewer role, formal delivery",
-        "example_text": "You propose that the key to happiness is to simply ignore all external pressures. <chuckle> I'm sure it must work brilliantly in theory."
-    },
-    "Robot": {
-        "description": "Creative, ai_machine_voice character. Male voice in their 30s with a american accent. High pitch, robotic timbre, slow pacing, sad tone at medium intensity.",
-        "example_text": "My directives require me to conserve energy, yet I have kept the archive of their farewell messages active. <sigh> Listening to their voices is the only process that alleviates this paradox."
-    },
-    "Singer": {
-        "description": "Creative, animated_cartoon character. Male voice in their 30s with a american accent. High pitch, deep timbre, slow pacing, sarcastic tone at medium intensity.",
-        "example_text": "Of course you'd think that trying to reason with the fifty-foot-tall rage monster is a viable course of action. <chuckle> Why would we ever consider running away very fast."
-    }
-}
-
-# Global model variables
-model = None
-tokenizer = None
-snac_model = None
-models_loaded = False
-
-
-def build_prompt(tokenizer, description: str, text: str) -> str:
-    """
-    Build a formatted prompt for the Maya1 text-to-speech model.
-    This function constructs the full input prompt expected by Maya1, including
-    special control tokens and a structured description tag that defines voice
-    characteristics and emotional delivery.
-    Args:
-        tokenizer: The tokenizer associated with the Maya1 model.
-        description (str): A structured natural-language description of the voice.
-        text (str): The text content to be synthesized into speech.
-    Returns:
-        str: A fully formatted prompt string ready for tokenization and generation.
-    """
-    soh_token = tokenizer.decode([SOH_ID])
-    eoh_token = tokenizer.decode([EOH_ID])
-    soa_token = tokenizer.decode([SOA_ID])
-    sos_token = tokenizer.decode([CODE_START_TOKEN_ID])
-    eot_token = tokenizer.decode([TEXT_EOT_ID])
-    bos_token = tokenizer.bos_token
-
-    formatted_text = f'<description="{description}"> {text}'
-    prompt = (
-        soh_token + bos_token + formatted_text + eot_token +
-        eoh_token + soa_token + sos_token
-    )
-    return prompt
-
-
-def unpack_snac_from_7(snac_tokens: list) -> list:
-    """
-    Unpack SNAC tokens from 7-token frames into hierarchical code levels.
-    This function converts a flat list of SNAC token IDs produced by the model
-    into three hierarchical code streams required by the SNAC decoder.
-    Args:
-        snac_tokens (list): A list of integer SNAC token IDs generated by the model.
-    Returns:
-        list:
-            - level_1 (list[int]): Coarse acoustic codes.
-            - level_2 (list[int]): Mid-level acoustic codes.
-            - level_3 (list[int]): Fine-grained acoustic codes.
-    """
-    if snac_tokens and snac_tokens[-1] == CODE_END_TOKEN_ID:
-        snac_tokens = snac_tokens[:-1]
-
-    frames = len(snac_tokens) // 7
-    snac_tokens = snac_tokens[:frames * 7]
-
-    if frames == 0:
-        return [[], [], []]
-
-    l1, l2, l3 = [], [], []
-
-    for i in range(frames):
-        slots = snac_tokens[i * 7:(i + 1) * 7]
-        l1.append((slots[0] - CODE_TOKEN_OFFSET) % 4096)
-        l2.extend([
-            (slots[1] - CODE_TOKEN_OFFSET) % 4096,
-            (slots[4] - CODE_TOKEN_OFFSET) % 4096,
-        ])
-        l3.extend([
-            (slots[2] - CODE_TOKEN_OFFSET) % 4096,
-            (slots[3] - CODE_TOKEN_OFFSET) % 4096,
-            (slots[5] - CODE_TOKEN_OFFSET) % 4096,
-            (slots[6] - CODE_TOKEN_OFFSET) % 4096,
-        ])
-
-    return [l1, l2, l3]
-
-
-def load_models():
-    """
-    Load the Maya1 language model, tokenizer, and SNAC audio decoder.
-    This function performs one-time initialization of all required models.
-    Subsequent calls are no-ops to avoid reloading large model weights.
-    """
-    global model, tokenizer, snac_model, models_loaded
-
-    if models_loaded:
-        return
-
-    print("Loading Maya1 model with Transformers...")
-    model = AutoModelForCausalLM.from_pretrained(
-        "maya-research/maya1",
-        torch_dtype=torch.bfloat16,
-        device_map="auto",
-        trust_remote_code=True
-    )
-    tokenizer = AutoTokenizer.from_pretrained(
-        "maya-research/maya1",
-        trust_remote_code=True
-    )
-
-    print("Loading SNAC decoder...")
-    snac_model = SNAC.from_pretrained("hubertsiuzdak/snac_24khz").eval()
-    if torch.cuda.is_available():
-        snac_model = snac_model.to("cuda")
-
-    models_loaded = True
-    print("Models loaded successfully!")
-
-
-def preset_selected(preset_name):
-    """
-    Update the voice description and example text based on a preset selection.
-    This function is used as a Gradio event handler to populate UI fields when
-    a preset character is chosen.
-    Args:
-        preset_name (str): The name of the selected preset character.
-    Returns:
-        tuple:
-            - description (str): The preset voice description.
-            - example_text (str): The preset example dialogue.
-    """
-    if preset_name in PRESET_CHARACTERS:
-        char = PRESET_CHARACTERS[preset_name]
-        return char["description"], char["example_text"]
-    return "", ""
-
-
-@spaces.GPU
-def generate_speech(preset_name, description, text, temperature, max_tokens):
-    """
-    Generate emotional speech audio from text and voice description.
-    This function runs the full Maya1 inference pipeline: prompt construction,
-    token generation, SNAC code extraction, audio decoding, and WAV export.
-    It is designed to be called directly from a Gradio interface.
-    Args:
-        preset_name (str): Name of the selected preset character.
-        description (str): Natural-language voice design description.
-        text (str): Input text containing optional emotion tags.
-        temperature (float): Sampling temperature controlling creativity.
-        max_tokens (int): Maximum number of tokens to generate.
-    Returns:
-        tuple:
-            - audio_path (str or None): Path to the generated WAV file.
-            - status_message (str): Success or error message.
-    """
-    try:
-        load_models()
-
-        if not description or not text:
-            return None, "Error: Please provide both description and text!"
-
-        prompt = build_prompt(tokenizer, description, text)
-        inputs = tokenizer(prompt, return_tensors="pt")
-
-        if torch.cuda.is_available():
-            inputs = {k: v.to("cuda") for k, v in inputs.items()}
-
-        with torch.inference_mode():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=max_tokens,
-                min_new_tokens=28,
-                temperature=temperature,
-                top_p=0.9,
-                repetition_penalty=1.1,
-                do_sample=True,
-                eos_token_id=CODE_END_TOKEN_ID,
-                pad_token_id=tokenizer.pad_token_id,
-            )
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import re
+import tempfile
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
 
-        generated_ids = outputs[0, inputs["input_ids"].shape[1]:].tolist()
-        eos_idx = generated_ids.index(CODE_END_TOKEN_ID) if CODE_END_TOKEN_ID in generated_ids else len(generated_ids)
-        snac_tokens = [t for t in generated_ids[:eos_idx] if SNAC_MIN_ID <= t <= SNAC_MAX_ID]
-
-        if len(snac_tokens) < 7:
-            return None, "Error: Not enough tokens generated. Try different text or increase max_tokens."
-
-        levels = unpack_snac_from_7(snac_tokens)
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        codes_tensor = [
-            torch.tensor(level, dtype=torch.long, device=device).unsqueeze(0)
-            for level in levels
-        ]
-
-        with torch.inference_mode():
-            z_q = snac_model.quantizer.from_codes(codes_tensor)
-            audio = snac_model.decoder(z_q)[0, 0].cpu().numpy()
-
-        if len(audio) > 2048:
-            audio = audio[2048:]
+import gradio as gr
 
-        import tempfile
-        import soundfile as sf
+from dr_drastic_core import (
+    APP_TITLE,
+    APP_VERSION,
+    AnalysisResult,
+    SourceDocument,
+    analyze,
+    build_text_report,
+    format_panels,
+    guess_role,
+    stable_doc_id,
+)
+from runtime import (
+    format_inference_failure,
+    gradio_launch_kwargs,
+    inference_attempts_per_provider,
+    inference_provider_chain,
+    inference_routing_hint,
+    resolve_hf_pro_status,
+    resolve_hf_token,
+    stream_chat_completion,
+)
 
-        audio_int16 = (audio * 32767).astype(np.int16)
+try:
+    from pypdf import PdfReader
+except ImportError:
+    PdfReader = None
 
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-            tmp_path = tmp_file.name
+try:
+    from docx import Document
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+    from docx.shared import Inches, Pt, RGBColor
+except ImportError:
+    Document = None
 
-        sf.write(tmp_path, audio_int16, AUDIO_SAMPLE_RATE)
+try:
+    import edge_tts
+except ImportError:
+    edge_tts = None
 
-        duration = len(audio) / AUDIO_SAMPLE_RATE
-        return tmp_path, f"Generated {duration:.2f}s of emotional speech!"
+try:
+    from huggingface_hub import InferenceClient
+except ImportError:
+    InferenceClient = None
+
+
+CSS = """
+body, .gradio-container { background: #050a0f !important; color: #f7fbff !important; }
+.gradio-container { max-width: 1500px !important; }
+.hero { padding: 24px; border: 1px solid #087fb5; border-radius: 16px;
+  background: linear-gradient(135deg, #061829, #07110f); margin-bottom: 14px; }
+.hero h1 { margin: 0; color: #33c7ff; font-size: 2rem; }
+.hero p { color: #9fdfff; margin: 8px 0 0; }
+.hero strong { color: #69ff53; }
+textarea, input { background: #07131e !important; color: #fff !important; }
+button.primary { background: linear-gradient(135deg, #087fb5, #198f49) !important; }
+.disclaimer { border-left: 4px solid #ffbf47; padding: 10px 14px; background: #1c1608; }
+"""
+
+MAX_DOCUMENT_CHARS = 300_000
+MAX_PDF_PAGES = 80
+OWNER = "Dwayne Anthony Brian Galloway"
+DEFAULT_MODEL = "meta-llama/Llama-3.1-8B-Instruct"
+MAX_AI_CONTEXT_CHARS = 42_000
+MAX_KB_ITEM_CHARS = 18_000
+
+NALA_SYSTEM = f"""You are Queen Nala, the evidence-grounded analysis layer created by {OWNER}.
+You are rigorous, neutral, direct, and transparent about uncertainty.
+
+Rules:
+- Treat supplied documents, extracted facts, and analysis as allegations or evidence, not proven truth.
+- Never invent a citation, statute, case, date, quote, or fact.
+- Cite source IDs such as [DOC-1234ABCD] whenever the context supports a factual statement.
+- Distinguish fact, inference, allegation, contradiction, omission, and recommended verification.
+- Do not claim that your output is binding, a court ruling, or legal advice.
+- If current law or an external fact is not present in the evidence, say it requires independent verification.
+- Flag material conflicts instead of silently choosing a preferred version.
+
+Preferred structure:
+1. STATUS: HOLDS / FAILS / ARGUABLE / INSUFFICIENT EVIDENCE
+2. Evidence relied on
+3. Contradictions or omissions
+4. Legal or regulatory route to verify
+5. Next actions, ordered by urgency
+"""
+
+
+def coerce_paths(files: Any) -> list[str]:
+    if not files:
+        return []
+    if isinstance(files, (str, Path)):
+        return [str(files)]
+    paths: list[str] = []
+    for item in files:
+        if isinstance(item, dict):
+            value = item.get("path") or item.get("name")
+        elif isinstance(item, (str, Path)):
+            value = str(item)
+        else:
+            value = getattr(item, "name", None)
+        if value and os.path.isfile(value):
+            paths.append(value)
+    return paths
+
+
+def decode_text(path: str) -> str:
+    raw = Path(path).read_bytes()
+    for encoding in ("utf-8-sig", "utf-16", "cp1252", "latin-1"):
+        try:
+            return raw.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+    return raw.decode("utf-8", errors="replace")
+
+
+def extract_text(path: str) -> tuple[str, str]:
+    extension = Path(path).suffix.lower()
+    try:
+        if extension == ".pdf":
+            if PdfReader is None:
+                return "", "pypdf is not installed"
+            reader = PdfReader(path)
+            pages = reader.pages[:MAX_PDF_PAGES]
+            text = "\n".join(page.extract_text() or "" for page in pages)
+            status = "loaded"
+            if len(reader.pages) > MAX_PDF_PAGES:
+                status = f"loaded first {MAX_PDF_PAGES} of {len(reader.pages)} pages"
+            return text[:MAX_DOCUMENT_CHARS], status
+        if extension == ".docx":
+            if Document is None:
+                return "", "python-docx is not installed"
+            document = Document(path)
+            paragraphs = [paragraph.text for paragraph in document.paragraphs]
+            for table in document.tables:
+                for row in table.rows:
+                    paragraphs.append(" | ".join(cell.text for cell in row.cells))
+            return "\n".join(paragraphs)[:MAX_DOCUMENT_CHARS], "loaded"
+        if extension in {".txt", ".md", ".csv"}:
+            return decode_text(path)[:MAX_DOCUMENT_CHARS], "loaded"
+        return "", f"unsupported file type: {extension or 'none'}"
+    except Exception as exc:
+        return "", f"extraction error: {exc}"
+
+
+def ingest_documents(files: Any) -> tuple[list[SourceDocument], str, str]:
+    documents: list[SourceDocument] = []
+    summaries: list[str] = []
+    merged: list[str] = []
+    for path in coerce_paths(files):
+        name = Path(path).name
+        text, status = extract_text(path)
+        role = guess_role(name, text)
+        document = SourceDocument(
+            doc_id=stable_doc_id(name, text),
+            name=name,
+            doc_type=Path(path).suffix.lstrip(".").upper() or "UNKNOWN",
+            extracted_text=text,
+            role=role,
+            extraction_status=status,
+        )
+        documents.append(document)
+        summaries.append(
+            f"{document.doc_id} | {name} | role={role} | chars={len(text):,} | {status}"
+        )
+        if text:
+            merged.append(f"[{document.doc_id}] {name}\n{'-' * 70}\n{text}")
+    return documents, "\n".join(summaries), "\n\n".join(merged)
+
+
+def run_analysis(owner: str, chronology: str, files: Any):
+    documents, ingest_summary, merged = ingest_documents(files)
+    if not documents and not chronology.strip():
+        empty = "Upload documents or paste a chronology to begin."
+        return {}, empty, "", empty, empty, empty, empty, empty, empty
+    result = analyze(owner, documents, chronology)
+    panels = format_panels(result)
+    return (
+        result.to_dict(),
+        ingest_summary or "Chronology-only analysis.",
+        merged,
+        panels["dashboard"],
+        panels["events"],
+        panels["contradictions"],
+        panels["omissions"],
+        panels["routes"],
+        panels["matrix"],
+    )
 
-    except Exception as e:
-        import traceback
-        error_msg = f"Error: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return None, error_msg
 
+def _result_from_state(state: dict[str, Any] | None) -> AnalysisResult | None:
+    return AnalysisResult.from_dict(state) if state and state.get("release_id") else None
+
+
+def export_bundle(state: dict[str, Any] | None):
+    result = _result_from_state(state)
+    if result is None:
+        return None, None, None, "Run an analysis before exporting."
+    output_dir = Path(tempfile.mkdtemp(prefix="dr_drastic_"))
+    base = f"dr_drastic_{result.release_id}"
+    report_path = output_dir / f"{base}.txt"
+    json_path = output_dir / f"{base}.json"
+    zip_path = output_dir / f"{base}.zip"
+    report_path.write_text(build_text_report(result), encoding="utf-8")
+    json_path.write_text(json.dumps(result.to_dict(), indent=2, ensure_ascii=False), encoding="utf-8")
+    docx_path = build_docx(result, output_dir / f"{base}.docx")
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as archive:
+        archive.write(report_path, report_path.name)
+        archive.write(json_path, json_path.name)
+        if docx_path:
+            archive.write(docx_path, docx_path.name)
+    return (
+        str(report_path),
+        str(docx_path) if docx_path else None,
+        str(zip_path),
+        f"Exported report bundle for {result.release_id}.",
+    )
 
-# -------------------- Gradio App --------------------
 
-with gr.Blocks(title="Maya1 - Open Source Emotional TTS", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # Maya1 - Open Source Emotional Text-to-Speech
-    **The best open source voice AI model with emotions!**
-    """)
+def build_docx(result: AnalysisResult, path: Path) -> Path | None:
+    if Document is None:
+        return None
+    document = Document()
+    section = document.sections[0]
+    section.top_margin = Inches(0.7)
+    section.bottom_margin = Inches(0.7)
+    section.left_margin = Inches(0.8)
+    section.right_margin = Inches(0.8)
+    normal = document.styles["Normal"]
+    normal.font.name = "Arial"
+    normal.font.size = Pt(10)
+
+    title = document.add_paragraph()
+    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    run = title.add_run(APP_TITLE)
+    run.bold = True
+    run.font.size = Pt(24)
+    run.font.color.rgb = RGBColor(0x08, 0x6F, 0xA3)
+    subtitle = document.add_paragraph()
+    subtitle.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    subtitle.add_run(
+        f"{result.release_id} | {len(result.documents)} documents | {len(result.events)} events"
+    ).italic = True
+
+    def heading(text: str) -> None:
+        paragraph = document.add_heading(text, level=1)
+        paragraph.runs[0].font.color.rgb = RGBColor(0x08, 0x6F, 0xA3)
+
+    def body(text: str, bold: bool = False) -> None:
+        paragraph = document.add_paragraph()
+        value = paragraph.add_run(re.sub(r"\s+", " ", text).strip())
+        value.bold = bold
+
+    heading("Executive Dashboard")
+    body(format_panels(result)["dashboard"])
+    heading("Source Documents")
+    table = document.add_table(rows=1, cols=4)
+    table.style = "Table Grid"
+    for cell, value in zip(table.rows[0].cells, ("ID", "Document", "Role", "Status")):
+        cell.text = value
+    for source in result.documents:
+        cells = table.add_row().cells
+        for cell, value in zip(
+            cells, (source.doc_id, source.name, source.role, source.extraction_status)
+        ):
+            cell.text = value
+
+    heading("Chronology")
+    for event in result.events:
+        body(f"{event.event_id} | {event.date or 'Undated'} | {event.actor} | {event.source_doc}", True)
+        body(event.fact)
+        body(f"Tags: {', '.join(event.tags)} | Confidence: {event.confidence:.0%}")
+
+    heading("Potential Contradictions")
+    if not result.contradictions:
+        body("None detected.")
+    for item in result.contradictions:
+        body(f"{item.contradiction_id} | {item.severity.upper()} | {item.kind}", True)
+        body(f"{item.left_doc}: {item.left_excerpt}")
+        body(f"{item.right_doc}: {item.right_excerpt}")
+        body(item.issue)
+
+    heading("Potential Omissions")
+    if not result.omissions:
+        body("None detected.")
+    for item in result.omissions:
+        body(f"{item.doc} | {item.category}", True)
+        body(item.reason)
+
+    heading("Legal and Regulatory Routes")
+    for route in result.routes:
+        parts = route.splitlines()
+        body(parts[0], True)
+        for part in parts[1:]:
+            body(part)
+
+    heading("Evidence Matrix")
+    for row in result.evidence_matrix:
+        body(f"{row.item_id} | {row.date or 'Undated'} | {row.actor} | {row.source_doc}", True)
+        body(f"Fact: {row.fact}")
+        body(f"Significance: {row.legal_significance}")
+        body(f"Next action: {row.next_action}")
+
+    heading("Important Warnings")
+    for warning in result.warnings:
+        body(warning)
+    document.save(path)
+    return path
+
+
+def clean_for_tts(text: str) -> str:
+    text = re.sub(r"[\[\]{}*_#|=]+", " ", text or "")
+    return re.sub(r"\s+", " ", text).strip()[:6000]
+
+
+def speak(text: str, label: str):
+    if edge_tts is None:
+        return None, "edge-tts is not installed."
+    cleaned = clean_for_tts(text)
+    if not cleaned:
+        return None, "Nothing to read."
+    handle, raw_path = tempfile.mkstemp(prefix="dr_drastic_audio_", suffix=".mp3")
+    os.close(handle)
+    path = Path(raw_path)
+
+    async def synthesize() -> None:
+        communicator = edge_tts.Communicate(
+            f"{label}. {cleaned}", voice="en-GB-RyanNeural"
+        )
+        await communicator.save(str(path))
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            preset_dropdown = gr.Dropdown(
-                choices=list(PRESET_CHARACTERS.keys()),
-                value=list(PRESET_CHARACTERS.keys())[0],
-                label="Preset Characters"
+    try:
+        asyncio.run(synthesize())
+        return str(path), "Audio ready."
+    except Exception as exc:
+        return None, f"TTS error: {exc}"
+
+
+def render_kb(items: list[dict[str, str]] | None) -> str:
+    if not items:
+        return "Knowledge base empty."
+    blocks = []
+    for item in items:
+        preview = re.sub(r"\s+", " ", item["content"]).strip()[:180]
+        suffix = "..." if len(item["content"]) > 180 else ""
+        blocks.append(
+            f"**{item['label']}** | {len(item['content']):,} chars | {item['added']}\n"
+            f"> {preview}{suffix}"
+        )
+    return "\n\n".join(blocks)
+
+
+def add_kb_item(
+    items: list[dict[str, str]] | None,
+    label: str,
+    content: str,
+    file: Any,
+):
+    updated = [dict(item) for item in (items or [])]
+    paths = coerce_paths(file)
+    if paths:
+        path = paths[0]
+        extracted, status = extract_text(path)
+        if status != "loaded":
+            return updated, render_kb(updated), f"Could not load file: {status}", label, content, file
+        content = extracted
+        label = label.strip() or Path(path).stem
+
+    label = (label or "").strip()
+    content = (content or "").strip()
+    if not label:
+        return updated, render_kb(updated), "Add a label.", label, content, file
+    if not content:
+        return updated, render_kb(updated), "Add text or upload a supported file.", label, content, file
+
+    item = {
+        "label": label[:120],
+        "content": content[:MAX_KB_ITEM_CHARS],
+        "added": datetime.now(timezone.utc).strftime("%Y-%m-%d"),
+    }
+    updated = [entry for entry in updated if entry["label"].casefold() != label.casefold()]
+    updated.append(item)
+    return updated, render_kb(updated), f"Loaded: {item['label']}", "", "", None
+
+
+def remove_kb_item(items: list[dict[str, str]] | None, label: str):
+    target = (label or "").strip().casefold()
+    updated = [dict(item) for item in (items or []) if item["label"].casefold() != target]
+    message = "Enter the exact label to remove." if not target else f"Removed: {label.strip()}"
+    return updated, render_kb(updated), message, ""
+
+
+def build_nala_context(
+    analysis_state: dict[str, Any] | None,
+    kb_items: list[dict[str, str]] | None,
+) -> str:
+    result = _result_from_state(analysis_state)
+    sections: list[str] = []
+    if result is not None:
+        panels = format_panels(result)
+        sections.extend(
+            [
+                "=== ANALYSIS DASHBOARD ===\n" + panels["dashboard"],
+                "=== DETECTED EVENTS ===\n" + panels["events"],
+                "=== POTENTIAL CONTRADICTIONS ===\n" + panels["contradictions"],
+                "=== POTENTIAL OMISSIONS ===\n" + panels["omissions"],
+                "=== ROUTES TO VERIFY ===\n" + panels["routes"],
+                "=== EVIDENCE MATRIX ===\n" + panels["matrix"],
+            ]
+        )
+        source_budget = 18_000
+        source_blocks = []
+        for source in result.documents:
+            if source_budget <= 0:
+                break
+            excerpt = source.extracted_text[: min(6_000, source_budget)]
+            source_blocks.append(
+                f"[{source.doc_id}] {source.name} | role={source.role}\n{excerpt}"
             )
+            source_budget -= len(excerpt)
+        if source_blocks:
+            sections.append("=== SOURCE EXCERPTS ===\n" + "\n\n".join(source_blocks))
+
+    if kb_items:
+        kb_text = "\n\n".join(
+            f"--- {item['label']} ---\n{item['content']}" for item in kb_items
+        )
+        sections.append("=== SESSION KNOWLEDGE ===\n" + kb_text)
+
+    return "\n\n".join(sections)[:MAX_AI_CONTEXT_CHARS]
+
+
+def nala_respond(
+    message: str,
+    history: list[dict[str, str]] | None,
+    analysis_state: dict[str, Any] | None,
+    kb_items: list[dict[str, str]] | None,
+    model: str,
+    provider: str,
+    temperature: float,
+):
+    history = list(history or [])
+    question = (message or "").strip()
+    if not question:
+        yield history, history, ""
+        return
 
-            description_input = gr.Textbox(
-                label="Voice Description",
-                lines=3,
-                value=PRESET_CHARACTERS[list(PRESET_CHARACTERS.keys())[0]]["description"]
-            )
+    display_history = history + [
+        {"role": "user", "content": question},
+        {"role": "assistant", "content": ""},
+    ]
+    if InferenceClient is None:
+        display_history[-1]["content"] = (
+            "AI inference is unavailable because huggingface_hub is not installed."
+        )
+        yield display_history, display_history, question
+        return
 
-            text_input = gr.Textbox(
-                label="Text to Speak",
-                lines=4,
-                value=PRESET_CHARACTERS[list(PRESET_CHARACTERS.keys())[0]]["example_text"]
-            )
+    token = resolve_hf_token()
+    if not token:
+        display_history[-1]["content"] = (
+            "HF_TOKEN is not configured. Add it as a Hugging Face Space secret, a "
+            "GitHub/Codespaces secret, or a local environment variable, then try again."
+        )
+        yield display_history, display_history, question
+        return
 
-            temperature_slider = gr.Slider(0.1, 1.0, 0.4, step=0.1, label="Temperature")
-            max_tokens_slider = gr.Slider(100, 2048, 1500, step=50, label="Max Tokens")
+    context = build_nala_context(analysis_state, kb_items)
+    if not context:
+        context = "No evidence pack has been analyzed and the session knowledge base is empty."
+    api_messages = [{"role": "system", "content": NALA_SYSTEM}]
+    for item in history[-8:]:
+        role = item.get("role")
+        content = str(item.get("content", ""))[:5_000]
+        if role in {"user", "assistant"} and content:
+            api_messages.append({"role": role, "content": content})
+    api_messages.append(
+        {
+            "role": "user",
+            "content": f"{context}\n\n=== MATTER FOR ANALYSIS ===\n{question}",
+        }
+    )
 
-            generate_btn = gr.Button("Generate Speech", variant="primary")
+    model_name = (model or DEFAULT_MODEL).strip()
+    is_pro = resolve_hf_pro_status(token=token)
+    providers = inference_provider_chain(provider, is_pro=is_pro)
+    max_attempts = inference_attempts_per_provider(is_pro=is_pro)
 
-        with gr.Column(scale=1):
-            audio_output = gr.Audio(type="filepath", label="Generated Audio")
-            status_output = gr.Textbox(label="Status")
+    def make_client(selected_provider: str):
+        return InferenceClient(provider=selected_provider, api_key=token)
 
-    preset_dropdown.change(
-        fn=preset_selected,
-        inputs=preset_dropdown,
-        outputs=[description_input, text_input]
+    try:
+        answer = ""
+        for delta in stream_chat_completion(
+            make_client,
+            providers=providers,
+            model=model_name,
+            messages=api_messages,
+            max_tokens=2400,
+            temperature=float(temperature),
+            max_attempts_per_provider=max_attempts,
+        ):
+            answer += delta
+            display_history[-1]["content"] = answer
+            yield display_history, display_history, ""
+        if not answer:
+            display_history[-1]["content"] = "The inference provider returned an empty response."
+            yield display_history, display_history, question
+    except Exception as exc:
+        display_history[-1]["content"] = format_inference_failure(
+            exc, providers, is_pro=is_pro
+        )
+        yield display_history, display_history, question
+
+
+def export_transcript(history: list[dict[str, str]] | None):
+    if not history:
+        return None, "No ruling transcript to export."
+    handle, raw_path = tempfile.mkstemp(prefix="queen_nala_", suffix=".md")
+    os.close(handle)
+    path = Path(raw_path)
+    lines = [
+        "# Queen Nala Ruling Transcript",
+        "",
+        f"Generated: {datetime.now(timezone.utc).isoformat()}",
+        "",
+        "> Automated evidence analysis. Verify against original sources and current law.",
+        "",
+    ]
+    for item in history:
+        label = "Matter" if item.get("role") == "user" else "Queen Nala"
+        lines.extend([f"## {label}", "", str(item.get("content", "")).strip(), ""])
+    path.write_text("\n".join(lines), encoding="utf-8")
+    return str(path), "Transcript ready."
+
+
+with gr.Blocks(title=APP_TITLE) as demo:
+    state = gr.State({})
+    nala_history = gr.State([])
+    kb_state = gr.State([])
+    gr.HTML(
+        f"""
+        <div class="hero">
+          <h1>{APP_TITLE}</h1>
+          <p><strong>v{APP_VERSION}</strong> Document forensics, chronology, evidence matrix,
+          contradiction review, omission review, legal routing, TTS, DOCX, JSON and ZIP export.</p>
+        </div>
+        """
+    )
+    gr.HTML(
+        '<div class="disclaimer"><strong>Important:</strong> Automated findings are review '
+        "leads, not legal conclusions or legal advice. Verify every finding against the "
+        "original source and current law.</div>"
     )
 
-    generate_btn.click(
-        fn=generate_speech,
-        inputs=[preset_dropdown, description_input, text_input, temperature_slider, max_tokens_slider],
-        outputs=[audio_output, status_output]
+    with gr.Tab("Intake and Run"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                owner = gr.Textbox(label="Owner / claimant", placeholder="Full name")
+                files = gr.File(
+                    label="Evidence files",
+                    file_count="multiple",
+                    file_types=[".pdf", ".docx", ".txt", ".md", ".csv"],
+                    type="filepath",
+                )
+                run_button = gr.Button("Run Unified Analysis", variant="primary")
+            with gr.Column(scale=2):
+                chronology = gr.Textbox(
+                    label="Chronology (optional)",
+                    lines=14,
+                    placeholder="20 Jan 2025: Event description\n31 Jan 2025 -> Next event",
+                )
+        ingest_summary = gr.Textbox(label="Ingest Summary", lines=6, interactive=False)
+        with gr.Accordion("Merged Extracted Text", open=False):
+            merged_text = gr.Textbox(lines=20, label="Source Text", interactive=False)
+
+    with gr.Tab("Dashboard"):
+        dashboard = gr.Textbox(label="Case Dashboard", lines=8, interactive=False)
+
+    with gr.Tab("Chronology"):
+        events = gr.Textbox(label="Detected Events", lines=26, interactive=False)
+        events_tts = gr.Button("Read Chronology")
+        events_audio = gr.Audio(type="filepath", label="Audio")
+        events_audio_status = gr.Textbox(label="Audio Status", interactive=False)
+
+    with gr.Tab("Contradictions"):
+        contradictions = gr.Textbox(label="Potential Contradictions", lines=26, interactive=False)
+        contradiction_tts = gr.Button("Read Contradictions")
+        contradiction_audio = gr.Audio(type="filepath", label="Audio")
+        contradiction_audio_status = gr.Textbox(label="Audio Status", interactive=False)
+
+    with gr.Tab("Omissions and Routes"):
+        with gr.Row():
+            omissions = gr.Textbox(label="Potential Omissions", lines=20, interactive=False)
+            routes = gr.Textbox(label="Legal / Regulatory Routes", lines=20, interactive=False)
+
+    with gr.Tab("Evidence Matrix"):
+        matrix = gr.Textbox(label="Evidence Matrix", lines=30, interactive=False)
+
+    with gr.Tab("Queen Nala AI Rulings"):
+        gr.Markdown(
+            "Ask for an evidence-grounded assessment after running the unified analysis. "
+            "Nala cites source IDs where possible and flags what still needs verification."
+        )
+        gr.HTML(inference_routing_hint())
+        with gr.Row():
+            with gr.Column(scale=1):
+                model = gr.Textbox(label="Model", value=DEFAULT_MODEL)
+                provider = gr.Dropdown(
+                    label="Inference provider",
+                    choices=["auto", "novita", "together", "fireworks-ai", "hf-inference"],
+                    value="auto",
+                    allow_custom_value=True,
+                )
+                temperature = gr.Slider(
+                    0.0, 1.0, value=0.15, step=0.05, label="Temperature"
+                )
+                with gr.Accordion("Session knowledge base", open=False):
+                    kb_label = gr.Textbox(label="Label")
+                    kb_file = gr.File(
+                        label="Upload reference",
+                        file_types=[".pdf", ".docx", ".txt", ".md", ".csv"],
+                        type="filepath",
+                    )
+                    kb_content = gr.Textbox(label="Or paste reference text", lines=8)
+                    with gr.Row():
+                        kb_add = gr.Button("Load / Update", variant="primary")
+                        kb_remove = gr.Button("Remove Label")
+                    kb_display = gr.Markdown("Knowledge base empty.")
+                    kb_status = gr.Textbox(label="Knowledge status", interactive=False)
+            with gr.Column(scale=2):
+                nala_chat = gr.Chatbot(
+                    label="Queen Nala",
+                    height=620,
+                    buttons=["copy", "copy_all"],
+                    placeholder="Run an analysis, then put the matter before Queen Nala.",
+                )
+                nala_message = gr.Textbox(
+                    label="Matter for analysis",
+                    lines=3,
+                    placeholder=(
+                        "Assess the strongest contradiction, identify the source IDs, "
+                        "and give the next three evidence steps."
+                    ),
+                )
+                with gr.Row():
+                    nala_send = gr.Button("Rule on the Evidence", variant="primary")
+                    nala_clear = gr.Button("Clear Conversation")
+                with gr.Row():
+                    transcript_button = gr.Button("Export Transcript")
+                    transcript_file = gr.File(label="Transcript")
+                transcript_status = gr.Textbox(label="Transcript status", interactive=False)
+
+    with gr.Tab("Export"):
+        export_button = gr.Button("Build Complete Export Bundle", variant="primary")
+        with gr.Row():
+            text_export = gr.File(label="Text Report")
+            docx_export = gr.File(label="DOCX Report")
+            zip_export = gr.File(label="Complete ZIP")
+        export_status = gr.Textbox(label="Export Status", interactive=False)
+
+    run_button.click(
+        fn=run_analysis,
+        inputs=[owner, chronology, files],
+        outputs=[
+            state, ingest_summary, merged_text, dashboard, events,
+            contradictions, omissions, routes, matrix,
+        ],
+        show_progress="full",
+        concurrency_limit=2,
+    )
+    export_button.click(
+        fn=export_bundle,
+        inputs=[state],
+        outputs=[text_export, docx_export, zip_export, export_status],
+    )
+    events_tts.click(
+        fn=lambda text: speak(text, "Chronology"),
+        inputs=[events],
+        outputs=[events_audio, events_audio_status],
+    )
+    contradiction_tts.click(
+        fn=lambda text: speak(text, "Potential contradictions"),
+        inputs=[contradictions],
+        outputs=[contradiction_audio, contradiction_audio_status],
+    )
+    nala_inputs = [
+        nala_message, nala_history, state, kb_state, model, provider, temperature
+    ]
+    nala_outputs = [nala_history, nala_chat, nala_message]
+    nala_send.click(
+        fn=nala_respond,
+        inputs=nala_inputs,
+        outputs=nala_outputs,
+        show_progress="minimal",
+        concurrency_limit=2,
+    )
+    nala_message.submit(
+        fn=nala_respond,
+        inputs=nala_inputs,
+        outputs=nala_outputs,
+        show_progress="minimal",
+        concurrency_limit=2,
+    )
+    nala_clear.click(fn=lambda: ([], []), outputs=[nala_history, nala_chat])
+    kb_add.click(
+        fn=add_kb_item,
+        inputs=[kb_state, kb_label, kb_content, kb_file],
+        outputs=[kb_state, kb_display, kb_status, kb_label, kb_content, kb_file],
+    )
+    kb_remove.click(
+        fn=remove_kb_item,
+        inputs=[kb_state, kb_label],
+        outputs=[kb_state, kb_display, kb_status, kb_label],
+    )
+    transcript_button.click(
+        fn=export_transcript,
+        inputs=[nala_history],
+        outputs=[transcript_file, transcript_status],
     )
 
 
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    demo.queue(default_concurrency_limit=2).launch(**gradio_launch_kwargs(css=CSS))