Initial deployment: PromiseTrack AI with 15 companies

.dockerignore

@@ -0,0 +1,32 @@
+# ── Raw source data — never deployed ─────────────────────────────────────────
+data/raw/
+data/interim/
+data/processed/
+data/vector/
+
+# ── Training-only model artifacts (not needed for inference) ─────────────────
+**/optimizer.pt
+**/scheduler.pt
+**/rng_state.pth
+
+# ── Pipeline scripts — not needed at runtime ──────────────────────────────────
+process_company.py
+XBRL/
+
+# ── Zipped archives ───────────────────────────────────────────────────────────
+*.zip
+
+# ── Python cache ──────────────────────────────────────────────────────────────
+__pycache__/
+*.py[cod]
+*.pyo
+.pytest_cache/
+
+# ── Dev/OS junk ───────────────────────────────────────────────────────────────
+.DS_Store
+.env
+*.log
+
+# ── Git ───────────────────────────────────────────────────────────────────────
+.git/
+.gitignore

.gitattributes

@@ -0,0 +1,7 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,31 @@
+# Raw data — never commit
+data/raw/
+data/interim/
+data/processed/
+data/vector/
+
+# Training artifacts not needed for inference
+**/optimizer.pt
+**/scheduler.pt
+**/rng_state.pth
+
+# Python cache
+__pycache__/
+*.py[cod]
+*.pyo
+.pytest_cache/
+
+# Environment & secrets
+.env
+
+# OS
+.DS_Store
+*.log
+
+# Pipeline scratch
+pipeline_run.log
+rebuild_rag.log
+app.zip
+pipelines.zip
+
+XBRL/

Dockerfile

@@ -0,0 +1,56 @@
+# ── Stage 1: Build image ──────────────────────────────────────────────────────
+FROM python:3.10-slim
+
+# System deps needed by some python packages (pdfplumber, lxml, etc.)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libglib2.0-0 \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# ── Install Python deps ───────────────────────────────────────────────────────
+COPY requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Download the sentence-transformer model at build time so it's baked in
+# (avoids downloading at runtime on every cold start)
+RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')"
+
+# ── Copy application code ─────────────────────────────────────────────────────
+COPY app/          app/
+COPY pipelines/    pipelines/
+COPY config.py     config.py
+COPY db.py         db.py
+COPY run.py        run.py
+
+# ── Copy pre-built databases (generated locally before deployment) ─────────────
+# These are read-only at runtime — no pipeline runs on the server.
+COPY promisetrack.db  promisetrack.db
+COPY chroma_db/       chroma_db/
+
+# ── Copy the trained DistilBERT model checkpoint ──────────────────────────────
+COPY claim_classification_model_distilbert_trained/ \
+     claim_classification_model_distilbert_trained/
+
+# ── Logo cache (optional — pre-warm if desired, otherwise fetched on demand) ──
+COPY data/logos/   data/logos/
+
+# ── Expose port 7860 (HuggingFace Spaces standard) ───────────────────────────
+EXPOSE 7860
+
+# ── Set env defaults (real secrets go in HF Space Settings > Secrets) ─────────
+ENV FLASK_HOST=0.0.0.0 \
+    FLASK_PORT=7860 \
+    FLASK_DEBUG=false
+
+# ── Run with Gunicorn (production-grade, matches your existing Space) ──────────
+# run:app = the `app` object created in run.py
+CMD ["gunicorn", \
+     "--bind", "0.0.0.0:7860", \
+     "--workers", "1", \
+     "--worker-class", "sync", \
+     "--worker-tmp-dir", "/dev/shm", \
+     "--timeout", "180", \
+     "run:app"]

README.md

@@ -0,0 +1,13 @@
+---
+title: PromiseTrack AI
+emoji: 📊
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+license: mit
+---
+
+# PromiseTrack AI
+
+An AI system that tracks forward-looking management commitments and measures whether they materialise in real financial outcomes.

app/__init__.py

@@ -0,0 +1,42 @@
+"""
+app/__init__.py
+Flask application factory.
+"""
+
+from flask import Flask
+
+import config
+from db import init_db
+from pipelines.ml.run_claim_model  import load_claim_model
+from pipelines.rag.build_vector_db import load_vector_db
+from pipelines.rag.rag_explainer   import load_groq_client
+
+
+def create_app() -> Flask:
+    app = Flask(
+        __name__,
+        template_folder="templates",
+        static_folder=str(config.FRONTEND_DIR),
+        static_url_path="",
+    )
+
+    app.secret_key                   = config.SECRET_KEY
+    app.config["MAX_CONTENT_LENGTH"] = 32 * 1024 * 1024
+    app.config["UPLOAD_FOLDER"]      = str(config.DATA_DIR)
+
+    # Initialise DB schema (creates tables if they don't exist)
+    init_db()
+
+    # Load heavyweight models once at startup
+    load_claim_model(config.MODEL_PATH)
+    load_vector_db(config.CHROMA_DB_PATH)
+    load_groq_client()
+
+    # Register blueprints
+    from app.routes.frontend import frontend_bp
+    from app.routes.pipeline import pipeline_bp
+
+    app.register_blueprint(pipeline_bp, url_prefix="/api")
+    app.register_blueprint(frontend_bp)
+
+    return app

app/routes/__init__.py

@@ -0,0 +1,16 @@
+"""
+app/routes/__init__.py
+Registers all blueprints with the Flask app.
+Import and call register_blueprints(app) from create_app().
+"""
+ 
+from flask import Flask
+ 
+ 
+def register_blueprints(app: Flask) -> None:
+    from app.routes.frontend import frontend_bp
+    from app.routes.pipeline import pipeline_bp
+ 
+    app.register_blueprint(frontend_bp)
+    app.register_blueprint(pipeline_bp, url_prefix="/api")
+ 

app/routes/frontend.py

@@ -0,0 +1,15 @@
+"""
+app/routes/frontend.py
+Serves the frontend index.html for all non-API routes.
+"""
+ 
+from flask import Blueprint, render_template
+ 
+frontend_bp = Blueprint("frontend", __name__)
+ 
+ 
+@frontend_bp.route("/", defaults={"path": ""})
+@frontend_bp.route("/<path:path>")
+def serve_frontend(path):
+    return render_template("index.html")
+ 

app/routes/pipeline.py

@@ -0,0 +1,153 @@
+"""
+app/routes/pipeline.py
+All API endpoints. Every route delegates to pipeline_service — no pipeline
+logic lives here.
+"""
+
+from flask import Blueprint, jsonify, request
+
+from app.services.pipeline_service import analyse_company, get_known_companies
+from pipelines.ml.run_claim_model  import is_model_loaded
+from pipelines.rag.build_vector_db import is_vector_db_loaded, build_vector_db
+
+pipeline_bp = Blueprint("pipeline", __name__)
+
+
+# ── Health check ──────────────────────────────────────────────────────────────
+
+@pipeline_bp.get("/health")
+def health():
+    return jsonify({
+        "status":           "ok",
+        "model_loaded":     is_model_loaded(),
+        "vector_db_loaded": is_vector_db_loaded(),
+    })
+
+
+# ── Companies list (for autocomplete) ────────────────────────────────────────
+
+@pipeline_bp.get("/companies")
+def companies():
+    return jsonify(get_known_companies())
+
+
+# ── Main analysis endpoint ────────────────────────────────────────────────────
+
+@pipeline_bp.post("/analyse")
+def analyse():
+    body    = request.get_json(silent=True) or {}
+    company = (body.get("company") or "").strip()
+    mode    = (body.get("mode")    or "full").strip().lower()
+
+    if not company:
+        return jsonify({"error": "company is required"}), 400
+    if mode not in ("full", "earnings", "financial"):
+        return jsonify({"error": "mode must be full | earnings | financial"}), 400
+
+    try:
+        result = analyse_company(company, mode)
+        # Cache miss — return 404 with helpful message
+        if "error" in result and result["error"] in ("not_found", "not_cached"):
+            return jsonify(result), 404
+        return jsonify(result)
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+
+
+# ── Vector DB query endpoint ─────────────────────────────────────────────────
+
+@pipeline_bp.post("/chat")
+def chat():
+    body    = request.get_json(silent=True) or {}
+    company = (body.get("company") or "").strip()
+    query   = (body.get("query") or "").strip()
+
+    if not company:
+        return jsonify({"error": "company is required"}), 400
+    if not query:
+        return jsonify({"error": "query is required"}), 400
+
+    try:
+        from app.services.pipeline_service import chat_with_company
+        result = chat_with_company(company, query)
+        if "error" in result and result["error"] == "not_found":
+            return jsonify(result), 404
+        return jsonify(result)
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+
+# ── Vector DB build endpoint (admin / one-time setup) ─────────────────────────
+
+@pipeline_bp.post("/admin/build-vector-db")
+def admin_build_vector_db():
+    body    = request.get_json(silent=True) or {}
+    records = body.get("verified_records", [])
+    if not records:
+        return jsonify({"error": "verified_records is required"}), 400
+    try:
+        status = build_vector_db(records)
+        return jsonify(status)
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+
+
+# ── Logo cache endpoint ──────────────────────────────────────────────────────
+
+@pipeline_bp.get("/logo/<company_name>")
+def get_company_logo(company_name):
+    import os
+    import requests
+    from flask import send_file
+    
+    LOGO_DEV_PUBLIC_KEY = 'pk_MmKxh9tYQ1Gvapx5RFmcTA'
+    LOGO_CACHE_DIR = os.path.join("data", "logos")
+    os.makedirs(LOGO_CACHE_DIR, exist_ok=True)
+    
+    # We use a safe filename
+    import re
+    safe_name = re.sub(r'[^a-zA-Z0-9_\-]', '_', company_name)
+    cache_path = os.path.join(LOGO_CACHE_DIR, f"{safe_name}.png")
+    
+    if os.path.exists(cache_path):
+        return send_file(os.path.abspath(cache_path), mimetype='image/png')
+        
+    DOMAIN_MAP = {
+        # Current folder names (updated after data reorganization)
+        "INFOSYS":              "infosys.com",
+        "BAJAJ FINANCE":        "bajajfinserv.in",
+        "Kotak Mahindra Bank":  "kotakbank.com",
+        "SUN PHARMA":           "sunpharma.com",
+        "Reliance  Industries": "ril.com",
+        "Reliance Industries":  "ril.com",
+        "TCS":                  "tcs.com",
+        "HDFC Bank":            "hdfcbank.com",
+        "Mahindra & Mahindra":  "mahindra.com",
+        "SBI":                  "sbi.co.in",
+        "ITC":                  "itcportal.com",
+        "L&T":                  "larsentoubro.com",
+        "ICICI Bank":           "icicibank.com",
+        "HCL":                  "hcltech.com",
+        "Bharthi Airtel":       "airtel.in",
+        "AXIS Bank":            "axisbank.com",
+    }
+
+    try:
+        if company_name in DOMAIN_MAP:
+            domain = DOMAIN_MAP[company_name]
+            url = f"https://img.logo.dev/{domain}?size=120&token={LOGO_DEV_PUBLIC_KEY}"
+        else:
+            import urllib.parse
+            encoded_name = urllib.parse.quote(company_name)
+            url = f"https://img.logo.dev/name/{encoded_name}?size=120&token={LOGO_DEV_PUBLIC_KEY}"
+        
+        response = requests.get(url, timeout=10)
+        
+        if response.status_code == 200:
+            with open(cache_path, 'wb') as f:
+                f.write(response.content)
+            return send_file(os.path.abspath(cache_path), mimetype='image/png')
+        else:
+            return jsonify({"error": "Logo not found"}), response.status_code
+            
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500

app/services/cache_service.py

@@ -0,0 +1,179 @@
+"""
+app/services/cache_service.py
+All SQLite read/write operations for the cache layer.
+No pipeline logic lives here — only DB operations.
+"""
+
+import json
+import re
+from datetime import datetime
+from typing import Optional
+
+from db import get_db
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _clean_display_name(folder_name: str) -> str:
+    """Strip year/quarter suffixes from folder names."""
+    name = re.sub(r'\s*\d{4}\s*Quarterly\s*Data\s*', '', folder_name, flags=re.IGNORECASE)
+    name = re.sub(r'\s*Quarterly\s*Data\s*', '', name, flags=re.IGNORECASE)
+    return name.strip()
+
+
+# ── Company registry ──────────────────────────────────────────────────────────
+
+def get_all_companies() -> list:
+    """Return all companies with their processing status."""
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT id, folder_name, display_name, status, processed_at FROM companies ORDER BY display_name"
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def get_ready_companies() -> list:
+    """Return only companies that have been successfully processed."""
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT id, folder_name, display_name, processed_at FROM companies WHERE status = 'ready' ORDER BY display_name"
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def get_company_by_folder(folder_name: str) -> Optional[dict]:
+    with get_db() as conn:
+        row = conn.execute(
+            "SELECT * FROM companies WHERE folder_name = ?", (folder_name,)
+        ).fetchone()
+    return dict(row) if row else None
+
+
+def upsert_company(folder_name: str, status: str = "pending", error_msg: str = None) -> int:
+    """Insert or update a company record. Returns company id."""
+    display = _clean_display_name(folder_name)
+    with get_db() as conn:
+        conn.execute("""
+            INSERT INTO companies (folder_name, display_name, status, processed_at, error_msg)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(folder_name) DO UPDATE SET
+                status       = excluded.status,
+                processed_at = excluded.processed_at,
+                error_msg    = excluded.error_msg
+        """, (folder_name, display, status,
+              datetime.utcnow().isoformat() if status == "ready" else None,
+              error_msg))
+        row = conn.execute(
+            "SELECT id FROM companies WHERE folder_name = ?", (folder_name,)
+        ).fetchone()
+    return row["id"]
+
+
+# ── Analysis cache ────────────────────────────────────────────────────────────
+
+def get_cached_analysis(company_id: int, mode: str) -> Optional[dict]:
+    """Return cached analysis result or None if not found."""
+    with get_db() as conn:
+        row = conn.execute(
+            "SELECT result_json FROM analysis_cache WHERE company_id = ? AND mode = ?",
+            (company_id, mode)
+        ).fetchone()
+    return json.loads(row["result_json"]) if row else None
+
+
+def save_analysis(company_id: int, mode: str, result: dict) -> None:
+    """Save (overwrite) analysis result for a company+mode."""
+    with get_db() as conn:
+        conn.execute("""
+            INSERT INTO analysis_cache (company_id, mode, result_json, created_at)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(company_id, mode) DO UPDATE SET
+                result_json = excluded.result_json,
+                created_at  = excluded.created_at
+        """, (company_id, mode, json.dumps(result), datetime.utcnow().isoformat()))
+
+
+# ── Claims ────────────────────────────────────────────────────────────────────
+
+def save_claims(company_id: int, claims: list) -> None:
+    """Overwrite all claims for a company."""
+    with get_db() as conn:
+        conn.execute("DELETE FROM claims WHERE company_id = ?", (company_id,))
+        conn.executemany("""
+            INSERT INTO claims
+              (company_id, quarter, sentence, metric, direction, magnitude, result, actual_change, confidence)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, [(
+            company_id,
+            c.get("quarter"),
+            c.get("sentence"),
+            c.get("metric"),
+            c.get("direction"),
+            c.get("magnitude"),
+            c.get("result"),
+            c.get("actual_change"),
+            c.get("confidence"),
+        ) for c in claims])
+
+
+def get_claims(company_id: int) -> list:
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT * FROM claims WHERE company_id = ? ORDER BY quarter", (company_id,)
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+# ── Timeseries ────────────────────────────────────────────────────────────────
+
+def save_timeseries(company_id: int, ts_records: list) -> None:
+    """Overwrite all timeseries rows for a company."""
+    with get_db() as conn:
+        conn.execute("DELETE FROM timeseries WHERE company_id = ?", (company_id,))
+        conn.executemany("""
+            INSERT OR REPLACE INTO timeseries
+              (company_id, quarter, revenue, net_profit, operating_profit, profit_margin,
+               revenue_qoq_change, net_profit_qoq_change, operating_profit_qoq_change, profit_margin_qoq_change,
+               revenue_yoy_change, net_profit_yoy_change, operating_profit_yoy_change, profit_margin_yoy_change)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, [(
+            company_id,
+            r.get("quarter"),
+            r.get("revenue"),
+            r.get("net_profit"),
+            r.get("operating_profit"),
+            r.get("profit_margin"),
+            r.get("revenue_qoq_change"),
+            r.get("net_profit_qoq_change"),
+            r.get("operating_profit_qoq_change"),
+            r.get("profit_margin_qoq_change"),
+            r.get("revenue_yoy_change"),
+            r.get("net_profit_yoy_change"),
+            r.get("operating_profit_yoy_change"),
+            r.get("profit_margin_yoy_change"),
+        ) for r in ts_records])
+
+
+# ── Risk ──────────────────────────────────────────────────────────────────────
+
+def save_risk(company_id: int, risk_records: list) -> None:
+    """Overwrite all risk rows for a company."""
+    with get_db() as conn:
+        conn.execute("DELETE FROM risk WHERE company_id = ?", (company_id,))
+        conn.executemany("""
+            INSERT OR REPLACE INTO risk
+              (company_id, quarter, total_claims, verification_rate, failure_rate,
+               partial_rate, direction_mismatch_rate, consistency_score, risk_drift, warning_flag)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, [(
+            company_id,
+            r.get("quarter"),
+            r.get("total_claims"),
+            r.get("verification_rate"),
+            r.get("failure_rate"),
+            r.get("partial_rate"),
+            r.get("direction_mismatch_rate"),
+            r.get("consistency_score"),
+            r.get("risk_drift"),
+            r.get("warning_flag"),
+        ) for r in risk_records])

app/services/pipeline_service.py

@@ -0,0 +1,163 @@
+"""
+app/services/pipeline_service.py
+Serves analysis results from SQLite cache.
+No pipeline logic runs here — all processing happens in process_company.py.
+"""
+
+import difflib
+from app.services.cache_service import (
+    get_ready_companies,
+    get_cached_analysis,
+)
+
+
+def get_known_companies() -> list:
+    """
+    Returns list of processed companies for the autocomplete dropdown.
+    Only companies with status='ready' are returned.
+    Automatically reflects new companies added via process_company.py.
+    """
+    return [
+        {"display": c["display_name"], "folder": c["folder_name"]}
+        for c in get_ready_companies()
+    ]
+
+
+def _fuzzy_match_company(query: str):
+    """
+    Finds the best matching company from the DB for a user query.
+    Tries exact → substring → difflib fuzzy in order.
+    Returns the full company DB row or None.
+    """
+    companies = get_ready_companies()
+    if not companies:
+        return None
+
+    query_lower = query.strip().lower()
+
+    lookup = {}
+    for c in companies:
+        lookup[c["display_name"].lower()] = c
+        lookup[c["folder_name"].lower()]  = c
+
+    if query_lower in lookup:
+        return lookup[query_lower]
+
+    for key, company in lookup.items():
+        if query_lower in key or key.startswith(query_lower):
+            return company
+
+    matches = difflib.get_close_matches(query_lower, lookup.keys(), n=1, cutoff=0.5)
+    if matches:
+        return lookup[matches[0]]
+
+    return None
+
+
+def analyse_company(company_name: str, mode: str) -> dict:
+    """
+    Looks up cached analysis for the best matching company.
+    Returns the cached result dict, or an informative error dict if not found.
+    """
+    company = _fuzzy_match_company(company_name)
+
+    if not company:
+        return {
+            "error":   "not_found",
+            "message": (
+                f"No processed data found for '{company_name}'. "
+                f"Run: python3 process_company.py \"{company_name}\""
+            ),
+            "company": company_name,
+            "mode":    mode,
+        }
+
+    result = get_cached_analysis(company["id"], mode)
+
+    if not result:
+        return {
+            "error":   "not_cached",
+            "message": (
+                f"'{company['display_name']}' is registered but mode '{mode}' "
+                f"has not been cached yet. "
+                f"Run: python3 process_company.py \"{company['display_name']}\""
+            ),
+            "company": company["display_name"],
+            "mode":    mode,
+        }
+
+    return result
+
+def chat_with_company(company_name: str, query: str) -> dict:
+    """
+    Handles interactive RAG chat by querying ChromaDB directly and passing context to Groq LLM.
+    """
+    company = _fuzzy_match_company(company_name)
+
+    if not company:
+        return {
+            "error":   "not_found",
+            "message": f"No processed data found for '{company_name}'.",
+            "company": company_name,
+        }
+
+    display_name = company["display_name"]
+
+    try:
+        import config
+        import chromadb
+        from groq import Groq
+
+        # 1. Query ChromaDB for relevant claims
+        chroma_client = chromadb.PersistentClient(path=config.CHROMA_DB_PATH)
+        collection = chroma_client.get_collection(name=config.CHROMA_COLLECTION)
+
+        results = collection.query(
+            query_texts=[query],
+            n_results=config.RAG_TOP_K,
+            where={"company": display_name}
+        )
+
+        # If no context is found
+        if not results or not results.get("documents") or not results["documents"][0]:
+            return {"answer": f"I couldn't find any specific claims or financial data regarding your query for {display_name} in my database."}
+
+        documents = results["documents"][0]
+        metadatas = results["metadatas"][0]
+
+        # 2. Format context for the LLM
+        context_blocks = []
+        for doc, meta in zip(documents, metadatas):
+            q = meta.get("quarter", "Unknown Qtr")
+            res = meta.get("result", "UNVERIFIED")
+            context_blocks.append(f"[{q}] Claim ({res}): {doc}")
+
+        context_str = "\n".join(context_blocks)
+
+        # 3. Ask Groq LLM
+        client = Groq(api_key=config.GROQ_API_KEY)
+        prompt = f"""You are a financial AI assistant answering questions about {display_name}.
+Use ONLY the following extracted claims and verified outcomes to answer the question.
+If the context doesn't contain the answer, explicitly state that you don't have enough information.
+Keep your answer concise, analytical, and professional.
+
+CONTEXT:
+{context_str}
+
+QUESTION:
+{query}
+"""
+
+        completion = client.chat.completions.create(
+            model=config.GROQ_MODEL,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.2,
+            max_tokens=600
+        )
+
+        return {"answer": completion.choices[0].message.content}
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return {"error": "rag_error", "answer": f"Backend connected, but RAG encountered an error: {str(e)}"}

app/templates/index.html

@@ -0,0 +1,855 @@
+<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>PromiseTrack AI</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&family=Playfair+Display:wght@600;700;800&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+    
+    <script>
+        tailwind.config = {
+            darkMode: 'class',
+            theme: {
+                extend: {
+                    fontFamily: {
+                        sans: ['DM Sans', 'sans-serif'],
+                        serif: ['Playfair Display', 'serif'],
+                        mono: ['JetBrains Mono', 'monospace'],
+                    },
+                    colors: {
+                        pt: {
+                            bg: '#0D1117',
+                            surface: '#161B22',
+                            accent: '#4493F8',
+                            success: '#3FB950',
+                            danger: '#F85149',
+                            warning: '#D29922'
+                        }
+                    }
+                }
+            }
+        }
+    </script>
+    <style>
+        body {
+            background-color: #F8FAFC; /* Light mode bg */
+            color: #0F172A; /* Light mode text */
+            position: relative;
+            overflow-x: hidden;
+            transition: background-color 0.3s ease, color 0.3s ease;
+        }
+
+        /* Dark mode body styles */
+        html.dark body {
+            background-color: theme('colors.pt.bg');
+            background-image: radial-gradient(circle at 45% 35%, #0D1F3C 0%, #0D1117 100%);
+            background-attachment: fixed;
+            color: #E6EDF3;
+        }
+
+        /* Nav & Panel Glass effects */
+        .glass-panel {
+            background: rgba(255, 255, 255, 0.9);
+            backdrop-filter: blur(24px);
+            -webkit-backdrop-filter: blur(24px);
+            border: 1px solid rgba(0, 0, 0, 0.08);
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.1);
+        }
+        
+        html.dark .glass-panel {
+            background: rgba(22, 27, 34, 0.75);
+            border: 1px solid rgba(255, 255, 255, 0.08);
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+        }
+
+        .glass-card {
+            background: rgba(255, 255, 255, 0.6);
+            backdrop-filter: blur(12px);
+            border: 1px solid rgba(0, 0, 0, 0.05);
+            transition: all 0.3s ease;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.05);
+        }
+
+        html.dark .glass-card {
+            background: rgba(30, 41, 59, 0.3);
+            border: 1px solid rgba(255, 255, 255, 0.05);
+            box-shadow: none;
+        }
+
+        .glass-card:hover {
+            border-color: rgba(68, 147, 248, 0.4);
+            transform: translateY(-4px);
+            box-shadow: 0 10px 30px -10px rgba(68, 147, 248, 0.15);
+        }
+
+        html.dark .glass-card:hover {
+            background: rgba(30, 41, 59, 0.6);
+            border-color: rgba(68, 147, 248, 0.3);
+            box-shadow: 0 10px 30px -10px rgba(68, 147, 248, 0.2);
+        }
+
+        /* Scrollbar styles */
+        .custom-scrollbar::-webkit-scrollbar { width: 6px; height: 6px; }
+        .custom-scrollbar::-webkit-scrollbar-track { background: rgba(0,0,0,0.05); border-radius: 4px; }
+        html.dark .custom-scrollbar::-webkit-scrollbar-track { background: rgba(0,0,0,0.2); }
+        
+        .custom-scrollbar::-webkit-scrollbar-thumb { background: rgba(0,0,0,0.2); border-radius: 4px; }
+        html.dark .custom-scrollbar::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.15); }
+        
+        .custom-scrollbar::-webkit-scrollbar-thumb:hover { background: rgba(0,0,0,0.3); }
+        html.dark .custom-scrollbar::-webkit-scrollbar-thumb:hover { background: rgba(255,255,255,0.25); }
+
+        .glow-text { text-shadow: 0 0 20px rgba(68, 147, 248, 0.2); }
+        html.dark .glow-text { text-shadow: 0 0 20px rgba(68, 147, 248, 0.4); }
+
+        /* SVG Graph Animation */
+        .draw-path {
+            stroke-dasharray: 500;
+            stroke-dashoffset: 500;
+            animation: drawPath 1.5s ease-in-out forwards;
+            animation-delay: 200ms;
+        }
+        @keyframes drawPath { to { stroke-dashoffset: 0; } }
+
+        /* General Animations */
+        .fade-in { animation: fadeIn 0.4s ease-out forwards; }
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        .hidden-panel {
+            opacity: 0;
+            pointer-events: none;
+            transform: scale(0.98);
+            transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        }
+        .show-panel {
+            opacity: 1;
+            pointer-events: auto;
+            transform: scale(1);
+            transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        }
+        
+        /* Chat bubble animations */
+        @keyframes bubbleIn {
+            from { opacity: 0; transform: translateY(8px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        .chat-bubble { animation: bubbleIn 0.3s ease-out forwards; }
+        
+        .typing-dot {
+            animation: typing 1.4s infinite ease-in-out both;
+        }
+        .typing-dot:nth-child(1) { animation-delay: -0.32s; }
+        .typing-dot:nth-child(2) { animation-delay: -0.16s; }
+        @keyframes typing {
+            0%, 80%, 100% { transform: scale(0); }
+            40% { transform: scale(1); }
+        }
+    </style>
+</head>
+<body class="antialiased min-h-screen flex flex-col">
+
+    <!-- Navbar -->
+    <nav class="sticky top-0 z-40 border-b border-slate-200 dark:border-white/5 bg-white/80 dark:bg-pt-bg/60 backdrop-blur-md transition-colors">
+        <div class="max-w-7xl mx-auto px-6 h-16 flex items-center justify-between">
+            <div class="flex items-center gap-2">
+                <span class="font-serif text-2xl font-bold text-slate-900 dark:text-white tracking-wide">PromiseTrack<sup class="text-pt-accent text-xs font-sans ml-0.5">AI</sup></span>
+            </div>
+            
+            <div class="flex items-center">
+                <!-- Theme Toggle Button -->
+                <button id="themeToggle" class="p-2 rounded-lg border border-slate-300 dark:border-slate-700 text-slate-600 dark:text-amber-400 hover:bg-slate-100 dark:hover:bg-slate-800 transition-colors" title="Toggle theme">
+                    <!-- Sun Icon (shows in dark mode) -->
+                    <svg id="themeIconSun" class="w-5 h-5 hidden" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z"></path></svg>
+                    <!-- Moon Icon (shows in light mode) -->
+                    <svg id="themeIconMoon" class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M20.354 15.354A9 9 0 018.646 3.646 9.003 9.003 0 0012 21a9.003 9.003 0 008.354-5.646z"></path></svg>
+                </button>
+            </div>
+        </div>
+    </nav>
+
+    <!-- Hero Section -->
+    <section class="max-w-7xl mx-auto px-6 pt-20 pb-16 lg:pt-32 lg:pb-24 grid lg:grid-cols-2 gap-12 lg:gap-8 items-center">
+        <div class="fade-in" style="animation-delay: 50ms;">
+            <h1 class="text-5xl lg:text-7xl font-serif font-bold mb-6 text-slate-900 dark:text-white leading-[1.15]">
+                Bridging What's<br/>Promised — With<br/>What's Delivered.
+            </h1>
+            <p class="text-lg text-slate-600 dark:text-slate-400 mb-10 max-w-lg leading-relaxed">
+                An AI system that tracks forward-looking management commitments and measures whether they materialise in real financial outcomes.
+            </p>
+            <div class="flex flex-wrap items-center gap-4">
+                <button onclick="document.getElementById('dashboard-view').scrollIntoView({behavior: 'smooth'})" class="bg-pt-accent hover:bg-blue-500 text-white px-6 py-3.5 rounded-xl font-semibold transition-all shadow-lg shadow-blue-500/20 flex items-center gap-2">
+                    Analyse a Company <span aria-hidden="true">&rarr;</span>
+                </button>
+                <button onclick="document.getElementById('dashboard-view').scrollIntoView({behavior: 'smooth'})" class="border border-slate-300 dark:border-slate-600 hover:border-slate-400 dark:hover:border-slate-400 hover:bg-slate-50 dark:hover:bg-white/5 text-slate-700 dark:text-slate-300 px-6 py-3.5 rounded-xl font-semibold transition-all">
+                    View Methodology
+                </button>
+            </div>
+        </div>
+        
+        <!-- Divergence SVG Illustration -->
+        <div class="fade-in hidden sm:block justify-self-center lg:justify-self-end w-full max-w-[500px]" style="animation-delay: 200ms;">
+            <svg viewBox="0 0 480 340" fill="none" xmlns="http://www.w3.org/2000/svg" class="w-full h-auto drop-shadow-2xl">
+                <!-- Promise Path -->
+                <path d="M100 220 C 180 160, 250 120, 360 90" class="draw-path" stroke="#4493F8" stroke-width="3" stroke-linecap="round"/>
+                <!-- Outcome Path -->
+                <path d="M100 220 C 180 245, 250 275, 360 295" class="draw-path" stroke="#F85149" stroke-width="3" stroke-linecap="round"/>
+                <!-- Divergence Area Fill -->
+                <path d="M100 220 C 180 160, 250 120, 360 90 L 360 295 C 250 275, 180 245, 100 220 Z" fill="rgba(68, 147, 248, 0.05)"/>
+                
+                <!-- Nodes -->
+                <circle cx="100" cy="220" r="6" class="fill-slate-800 dark:fill-[#E6EDF3]"/>
+                <circle cx="360" cy="90" r="5" fill="#4493F8"/>
+                <circle cx="360" cy="295" r="5" fill="#F85149"/>
+                
+                <!-- Labels -->
+                <text x="372" y="95" fill="#4493F8" font-size="14" font-family="DM Sans" font-weight="600">Promise</text>
+                <text x="372" y="300" fill="#F85149" font-size="14" font-family="DM Sans" font-weight="600">Outcome</text>
+                
+                <!-- Annotations -->
+                <text x="210" y="198" class="fill-slate-500 dark:fill-[#8B949E]" font-size="11" font-family="JetBrains Mono">Divergence</text>
+                <line x1="205" y1="195" x2="205" y2="170" class="stroke-slate-500 dark:stroke-[#8B949E]" stroke-width="1" stroke-dasharray="2 2" opacity="0.5"/>
+                <text x="110" y="238" class="fill-slate-500 dark:fill-[#8B949E]" font-size="10" font-family="JetBrains Mono">Q1 Earnings Call</text>
+            </svg>
+        </div>
+    </section>
+
+    <!-- Main Dashboard View -->
+    <main id="dashboard-view" class="flex-1 max-w-7xl mx-auto w-full px-6 py-12 transition-opacity duration-300 border-t border-slate-200 dark:border-white/5 mt-10">
+        <header class="mb-8">
+            <h2 class="text-3xl font-serif font-bold text-slate-900 dark:text-white mb-3">Company Intelligence</h2>
+            <p class="text-slate-600 dark:text-slate-400 text-base max-w-2xl mb-8">Select a company from the repository to extract verified performance metrics against historical management claims.</p>
+            
+            <!-- Search Bar -->
+            <div class="relative max-w-md">
+                <input type="text" id="companySearch" placeholder="Search companies by name or ticker..." 
+                    class="w-full bg-white dark:bg-[#161B22] border border-slate-300 dark:border-slate-700 rounded-xl px-4 py-3 pl-11 text-slate-900 dark:text-white focus:outline-none focus:border-pt-accent focus:ring-1 focus:ring-pt-accent transition-colors shadow-sm">
+                <svg class="w-5 h-5 absolute left-4 top-3.5 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"></path>
+                </svg>
+            </div>
+        </header>
+
+        <!-- Flashcards Grid -->
+        <div id="flashcards-container" class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6">
+            <!-- Loading Skeletons -->
+            <div class="glass-card rounded-2xl p-6 h-40 animate-pulse flex flex-col justify-center">
+                <div class="h-6 w-3/4 bg-slate-200 dark:bg-slate-700/50 rounded mb-4"></div>
+                <div class="h-4 w-1/2 bg-slate-200 dark:bg-slate-700/30 rounded"></div>
+            </div>
+            <div class="glass-card rounded-2xl p-6 h-40 animate-pulse flex flex-col justify-center">
+                <div class="h-6 w-2/3 bg-slate-200 dark:bg-slate-700/50 rounded mb-4"></div>
+                <div class="h-4 w-1/2 bg-slate-200 dark:bg-slate-700/30 rounded"></div>
+            </div>
+        </div>
+        
+        <!-- Empty state (hidden by default) -->
+        <div id="no-results" class="hidden py-12 text-center border border-dashed border-slate-300 dark:border-white/20 rounded-2xl mt-6">
+            <p class="text-slate-500 dark:text-slate-400">No companies found matching your search.</p>
+        </div>
+    </main>
+
+    <!-- Analysis Overlay (Glass Panel) -->
+    <div id="analysis-overlay" class="fixed inset-0 z-50 flex items-center justify-center p-4 sm:p-6 hidden-panel bg-slate-900/40 dark:bg-black/60 backdrop-blur-sm">
+        <div class="glass-panel w-full max-w-7xl h-full max-h-[92vh] rounded-3xl flex flex-col overflow-hidden relative">
+            
+            <!-- Header -->
+            <div class="px-8 py-6 border-b border-slate-200 dark:border-white/10 bg-slate-50/50 dark:bg-slate-800/20 flex flex-col sm:flex-row justify-between items-start sm:items-center gap-4 flex-shrink-0">
+                <div>
+                    <div class="flex items-center gap-3 mb-1">
+                        <h2 id="panel-company-name" class="text-3xl font-bold text-slate-900 dark:text-white font-serif">Company Name</h2>
+                        <span id="panel-verdict" class="px-3 py-1 rounded-full text-xs font-bold uppercase tracking-wider border">Verdict</span>
+                    </div>
+                    <p id="panel-source" class="text-slate-500 dark:text-slate-400 text-sm font-mono">Source Details</p>
+                </div>
+                <div class="flex items-center gap-4 w-full sm:w-auto justify-end">
+                    <!-- Close button -->
+                    <button id="close-panel-btn" class="p-2 rounded-full hover:bg-slate-200 dark:hover:bg-white/10 text-slate-500 dark:text-slate-300 transition-colors bg-white dark:bg-white/5 border border-slate-200 dark:border-white/10 shadow-sm" title="Close Analysis">
+                        <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path></svg>
+                    </button>
+                </div>
+            </div>
+
+            <!-- Scrollable Body -->
+            <div class="flex-1 overflow-y-auto custom-scrollbar p-8 space-y-10" id="panel-content">
+                
+                <div class="grid grid-cols-1 xl:grid-cols-3 gap-8">
+                    <!-- Left: RAG Engine & Ask RAG -->
+                    <div class="xl:col-span-2 space-y-6">
+                        <div class="flex items-center gap-2 mb-4">
+                            <div class="w-2 h-6 bg-pt-accent rounded-sm"></div>
+                            <h3 class="text-xl font-bold text-slate-900 dark:text-white">RAG Intelligence Engine</h3>
+                        </div>
+                        
+                        <!-- AI Explanation -->
+                        <div class="bg-white dark:bg-[#0D1117]/80 border border-slate-200 dark:border-pt-accent/20 rounded-2xl p-6 shadow-sm dark:shadow-inner">
+                            <h4 class="text-xs font-mono text-pt-accent mb-3 uppercase tracking-widest">Synthesized Analysis</h4>
+                            <div id="panel-explanation" class="text-slate-700 dark:text-slate-300 leading-relaxed space-y-3 text-sm sm:text-base">
+                                <!-- Explanation content -->
+                            </div>
+                        </div>
+
+                        <!-- Ask RAG Chat UI (Staged) -->
+                        <div class="bg-white dark:bg-[#0D1117]/80 border border-slate-200 dark:border-pt-accent/20 rounded-2xl p-6 shadow-sm dark:shadow-inner mt-6 flex flex-col h-[400px]">
+                            <h4 class="text-xs font-mono text-pt-accent mb-4 uppercase tracking-widest flex items-center gap-2">
+                                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 10h.01M12 10h.01M16 10h.01M9 16H5a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2h-5l-5 5v-5z"></path></svg> 
+                                Ask RAG (Vector Search)
+                            </h4>
+                            
+                            <!-- Chat Area -->
+                            <div id="rag-chat-history" class="flex-1 overflow-y-auto custom-scrollbar space-y-4 mb-4 pr-2">
+                                <!-- Initial Greeting -->
+                                <div class="flex flex-col gap-1 items-start">
+                                    <div class="bg-slate-100 dark:bg-slate-800/60 text-slate-800 dark:text-slate-200 px-4 py-3 rounded-2xl rounded-tl-sm text-sm max-w-[85%] border border-slate-200 dark:border-white/5">
+                                        Hello! I have loaded all the contextual transcripts and financial reports for this company. Ask me anything about their forward-looking guidance, margins, or risk factors.
+                                    </div>
+                                    <span class="text-[10px] text-slate-400 font-mono ml-1">AI Agent</span>
+                                </div>
+                            </div>
+
+                            <!-- Chat Input -->
+                            <form id="rag-chat-form" class="relative mt-auto">
+                                <input type="text" id="rag-chat-input" placeholder="e.g. What did management say about expected revenue growth?" 
+                                    class="w-full bg-slate-50 dark:bg-[#161B22] border border-slate-300 dark:border-slate-700 rounded-xl px-4 py-3 pr-12 text-slate-900 dark:text-white focus:outline-none focus:border-pt-accent transition-colors text-sm shadow-inner">
+                                <button type="submit" class="absolute right-2 top-2 p-1.5 bg-pt-accent text-white rounded-lg hover:bg-blue-500 transition-colors shadow-md">
+                                    <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14 5l7 7m0 0l-7 7m7-7H3"></path></svg>
+                                </button>
+                            </form>
+                        </div>
+
+                        <!-- Signals -->
+                        <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mt-6">
+                            <!-- Positive -->
+                            <div class="bg-emerald-50 dark:bg-emerald-950/20 border border-emerald-200 dark:border-emerald-500/20 rounded-2xl p-5">
+                                <h4 class="text-xs font-mono text-emerald-600 dark:text-emerald-400 mb-4 uppercase tracking-widest flex items-center gap-2">
+                                    <span class="w-2 h-2 rounded-full bg-emerald-500 dark:bg-emerald-400"></span> Positive Signals
+                                </h4>
+                                <div id="panel-positive" class="space-y-4">
+                                    <!-- Positive signals list -->
+                                </div>
+                            </div>
+                            <!-- Negative -->
+                            <div class="bg-rose-50 dark:bg-rose-950/20 border border-rose-200 dark:border-rose-500/20 rounded-2xl p-5">
+                                <h4 class="text-xs font-mono text-rose-600 dark:text-rose-400 mb-4 uppercase tracking-widest flex items-center gap-2">
+                                    <span class="w-2 h-2 rounded-full bg-rose-500 dark:bg-rose-400"></span> Negative Signals
+                                </h4>
+                                <div id="panel-negative" class="space-y-4">
+                                    <!-- Negative signals list -->
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Right: Metrics Snapshot -->
+                    <div class="space-y-6">
+                        <div class="flex items-center gap-2 mb-4">
+                            <div class="w-2 h-6 bg-slate-400 dark:bg-slate-600 rounded-sm"></div>
+                            <h3 class="text-xl font-bold text-slate-900 dark:text-white">Financial Snapshot</h3>
+                        </div>
+
+                        <!-- Metrics Grid -->
+                        <div class="grid grid-cols-2 xl:grid-cols-1 gap-4" id="panel-metrics">
+                            <!-- Metric cards -->
+                        </div>
+
+                        <!-- QoQ Bars -->
+                        <div class="bg-white dark:bg-[#0D1117]/60 border border-slate-200 dark:border-white/5 rounded-2xl p-5 mt-6 shadow-sm">
+                            <h4 class="text-xs font-mono text-slate-500 dark:text-slate-400 mb-4 uppercase tracking-widest">Quarter-over-Quarter</h4>
+                            <div id="panel-bar-metrics" class="space-y-4">
+                                <!-- Bar metrics -->
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Claim Tracker Table -->
+                <div class="pt-6 border-t border-slate-200 dark:border-white/10">
+                    <div class="flex items-center gap-2 mb-4">
+                        <div class="w-2 h-6 bg-purple-500 rounded-sm"></div>
+                        <h3 class="text-xl font-bold text-slate-900 dark:text-white">Commitment Tracker</h3>
+                    </div>
+                    
+                    <div class="bg-white dark:bg-[#0D1117]/60 border border-slate-200 dark:border-white/10 rounded-2xl overflow-hidden shadow-sm">
+                        <div class="overflow-x-auto custom-scrollbar">
+                            <table class="w-full text-left text-sm whitespace-nowrap">
+                                <thead class="bg-slate-50 dark:bg-slate-800/30 text-slate-500 dark:text-slate-400 font-mono text-xs uppercase tracking-wider">
+                                    <tr>
+                                        <th class="px-6 py-4 font-medium border-b border-slate-200 dark:border-transparent">Quarter</th>
+                                        <th class="px-6 py-4 font-medium border-b border-slate-200 dark:border-transparent w-full max-w-md">Extracted Claim</th>
+                                        <th class="px-6 py-4 font-medium border-b border-slate-200 dark:border-transparent">Metric</th>
+                                        <th class="px-6 py-4 font-medium border-b border-slate-200 dark:border-transparent">Direction</th>
+                                        <th class="px-6 py-4 font-medium border-b border-slate-200 dark:border-transparent">Verification</th>
+                                    </tr>
+                                </thead>
+                                <tbody id="panel-claims" class="divide-y divide-slate-100 dark:divide-white/5 text-slate-700 dark:text-slate-300">
+                                    <!-- Claims rows -->
+                                </tbody>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+
+            </div>
+        </div>
+    </div>
+
+    <!-- Global Loader -->
+    <div id="global-loader" class="fixed inset-0 z-[100] bg-white/90 dark:bg-pt-bg/90 backdrop-blur-md hidden flex-col items-center justify-center transition-opacity">
+        <div class="relative w-24 h-24 mb-6">
+            <svg class="animate-spin w-full h-full text-slate-200 dark:text-white/10" viewBox="0 0 100 100">
+                <circle cx="50" cy="50" r="45" fill="none" stroke="currentColor" stroke-width="8"></circle>
+            </svg>
+            <svg class="animate-spin w-full h-full text-pt-accent absolute top-0 left-0" viewBox="0 0 100 100" style="animation-direction: reverse; animation-duration: 1.5s;">
+                <circle cx="50" cy="50" r="45" fill="none" stroke="currentColor" stroke-width="8" stroke-dasharray="80 200" stroke-linecap="round"></circle>
+            </svg>
+        </div>
+        <h2 class="text-2xl font-serif font-bold text-slate-900 dark:text-white tracking-wide">Processing Pipeline</h2>
+        <p class="text-pt-accent mt-2 font-mono text-sm" id="loader-status">Running models...</p>
+    </div>
+
+    <script>
+        // --- Theme Logic ---
+        const themeToggleBtn = document.getElementById('themeToggle');
+        const themeIconSun = document.getElementById('themeIconSun');
+        const themeIconMoon = document.getElementById('themeIconMoon');
+        const htmlEl = document.documentElement;
+
+        // Ensure default to dark mode unless explicitly set to light
+        if (localStorage.getItem('theme') === 'light') {
+            htmlEl.classList.remove('dark');
+            if (themeIconSun) themeIconSun.classList.add('hidden');
+            if (themeIconMoon) themeIconMoon.classList.remove('hidden');
+        } else {
+            htmlEl.classList.add('dark');
+            if (themeIconSun) themeIconSun.classList.remove('hidden');
+            if (themeIconMoon) themeIconMoon.classList.add('hidden');
+        }
+
+        if (themeToggleBtn) {
+            themeToggleBtn.addEventListener('click', () => {
+                htmlEl.classList.toggle('dark');
+                if (htmlEl.classList.contains('dark')) {
+                    localStorage.setItem('theme', 'dark');
+                    themeIconSun.classList.remove('hidden');
+                    themeIconMoon.classList.add('hidden');
+                } else {
+                    localStorage.setItem('theme', 'light');
+                    themeIconSun.classList.add('hidden');
+                    themeIconMoon.classList.remove('hidden');
+                }
+            });
+        }
+
+        // DOM Elements
+        const API_BASE = '/api';
+        const flashcardsContainer = document.getElementById('flashcards-container');
+        const searchInput = document.getElementById('companySearch');
+        const noResults = document.getElementById('no-results');
+        const overlay = document.getElementById('analysis-overlay');
+        const closeBtn = document.getElementById('close-panel-btn');
+        const loader = document.getElementById('global-loader');
+        const loaderStatus = document.getElementById('loader-status');
+
+        // Current state
+        let currentCompany = null;
+        let allCompanies = [];
+
+        // --- Initialization ---
+        document.addEventListener('DOMContentLoaded', () => {
+            fetchCompanies();
+        });
+
+        async function fetchCompanies() {
+            try {
+                const res = await fetch(`${API_BASE}/companies`);
+                if (!res.ok) throw new Error('Failed to fetch companies');
+                allCompanies = await res.json();
+                renderFlashcards(allCompanies);
+            } catch (error) {
+                console.warn('API fetch failed, loading dummy data for UI testing...', error);
+                // Fallback dummy data if backend is offline
+                allCompanies = [
+                    { display: "Axis Bank Ltd", folder: "AXISBANK" },
+                    { display: "Infosys Limited", folder: "INFY" },
+                    { display: "Reliance Industries", folder: "RELIANCE" },
+                    { display: "Tata Motors", folder: "TATAMOTORS" },
+                    { display: "HDFC Bank", folder: "HDFCBANK" },
+                    { display: "Larsen & Toubro", folder: "LT" }
+                ];
+                renderFlashcards(allCompanies);
+            }
+        }
+
+        // --- Search/Filter Logic ---
+        searchInput.addEventListener('input', (e) => {
+            const query = e.target.value.toLowerCase();
+            const filtered = allCompanies.filter(comp => 
+                comp.display.toLowerCase().includes(query) || 
+                comp.folder.toLowerCase().includes(query)
+            );
+            
+            if (filtered.length === 0) {
+                flashcardsContainer.innerHTML = '';
+                noResults.classList.remove('hidden');
+            } else {
+                noResults.classList.add('hidden');
+                renderFlashcards(filtered);
+            }
+        });
+
+        function renderFlashcards(companies) {
+            flashcardsContainer.innerHTML = '';
+            
+            if (!companies || companies.length === 0) return;
+
+            companies.forEach((comp, index) => {
+                const delay = (index % 10) * 30; // Stagger animation
+                const card = document.createElement('div');
+                card.className = `glass-card rounded-2xl cursor-pointer min-h-[160px] fade-in relative overflow-hidden group`;
+                card.style.animationDelay = `${delay}ms`;
+                
+                card.innerHTML = `
+                    <div class="absolute -right-4 -bottom-4 w-32 h-32 opacity-[0.08] dark:opacity-[0.15] mix-blend-luminosity group-hover:opacity-20 transition-opacity pointer-events-none" 
+                         style="background-image: url('${API_BASE}/logo/${comp.folder}'); background-size: contain; background-repeat: no-repeat; background-position: center;">
+                    </div>
+                    <div class="p-6 h-full flex flex-col justify-between relative z-10">
+                        <div>
+                            <div class="w-10 h-10 rounded-full bg-white dark:bg-[#0D1117] border border-slate-200 dark:border-white/10 flex items-center justify-center font-serif text-lg text-slate-800 dark:text-white shadow-sm dark:shadow-inner overflow-hidden">
+                                <img src="${API_BASE}/logo/${comp.folder}" alt="logo" class="w-full h-full object-contain p-1" onerror="this.onerror=null; this.parentElement.innerHTML='${comp.display.charAt(0)}';" />
+                            </div>
+                        </div>
+                        <div class="mt-4">
+                            <h3 class="text-xl font-bold text-slate-900 dark:text-white truncate">${comp.display}</h3>
+                            <p class="text-sm text-slate-500 dark:text-slate-400 font-mono mt-1">${comp.folder}</p>
+                        </div>
+                    </div>
+                `;
+                
+                card.addEventListener('click', () => openAnalysis(comp.folder));
+                flashcardsContainer.appendChild(card);
+            });
+        }
+
+        // --- Analysis Overlay Logic ---
+        async function openAnalysis(companyId) {
+            currentCompany = companyId;
+            showLoader();
+            resetRagChat(); // Clear old chat history
+
+            try {
+                // Hardcoded to 'full' mode 
+                const res = await fetch(`${API_BASE}/analyse`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ company: companyId, mode: 'full' })
+                });
+                
+                if (!res.ok) {
+                    const errorData = await res.json();
+                    throw new Error(errorData.message || errorData.error || 'Failed to analyze');
+                }
+                
+                const data = await res.json();
+                populatePanel(data);
+                
+                // Show panel
+                overlay.classList.remove('hidden');
+                setTimeout(() => {
+                    overlay.classList.remove('hidden-panel');
+                    overlay.classList.add('show-panel');
+                    document.body.style.overflow = 'hidden'; // prevent bg scrolling
+                }, 10);
+                
+            } catch (error) {
+                console.error("Analysis Error:", error);
+                alert(`Analysis Error: ${error.message}`);
+            } finally {
+                hideLoader();
+            }
+        }
+
+        function closePanel() {
+            overlay.classList.remove('show-panel');
+            overlay.classList.add('hidden-panel');
+            setTimeout(() => {
+                overlay.classList.add('hidden');
+                document.body.style.overflow = '';
+            }, 300);
+        }
+        
+        closeBtn.addEventListener('click', closePanel);
+        overlay.addEventListener('click', (e) => {
+            if (e.target === overlay) closePanel();
+        });
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape' && overlay.classList.contains('show-panel')) closePanel();
+        });
+
+        // --- Ask RAG Chat Logic (Staged/Mocked) ---
+        const chatForm = document.getElementById('rag-chat-form');
+        const chatInput = document.getElementById('rag-chat-input');
+        const chatHistory = document.getElementById('rag-chat-history');
+
+        function resetRagChat() {
+            chatHistory.innerHTML = `
+                <div class="flex flex-col gap-1 items-start">
+                    <div class="bg-slate-100 dark:bg-slate-800/60 text-slate-800 dark:text-slate-200 px-4 py-3 rounded-2xl rounded-tl-sm text-sm max-w-[85%] border border-slate-200 dark:border-white/5">
+                        Hello! I have loaded all the contextual transcripts and financial reports for this company. Ask me anything about their forward-looking guidance, margins, or risk factors.
+                    </div>
+                    <span class="text-[10px] text-slate-400 font-mono ml-1">AI Agent</span>
+                </div>
+            `;
+            chatInput.value = '';
+        }
+
+        chatForm.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const message = chatInput.value.trim();
+            if (!message) return;
+
+            // 1. Add User Message
+            const userHtml = `
+                <div class="flex flex-col gap-1 items-end chat-bubble">
+                    <div class="bg-pt-accent text-white px-4 py-3 rounded-2xl rounded-tr-sm text-sm max-w-[85%] shadow-md">
+                        ${message}
+                    </div>
+                    <span class="text-[10px] text-slate-400 font-mono mr-1">You</span>
+                </div>
+            `;
+            chatHistory.insertAdjacentHTML('beforeend', userHtml);
+            chatInput.value = '';
+            scrollToBottom();
+
+            // 2. Add Loading Indicator
+            const loaderId = 'loader-' + Date.now();
+            const loadingHtml = `
+                <div id="${loaderId}" class="flex flex-col gap-1 items-start chat-bubble">
+                    <div class="bg-slate-100 dark:bg-slate-800/60 px-4 py-4 rounded-2xl rounded-tl-sm max-w-[85%] border border-slate-200 dark:border-white/5 flex gap-1 items-center">
+                        <div class="w-2 h-2 bg-slate-400 rounded-full typing-dot"></div>
+                        <div class="w-2 h-2 bg-slate-400 rounded-full typing-dot"></div>
+                        <div class="w-2 h-2 bg-slate-400 rounded-full typing-dot"></div>
+                    </div>
+                </div>
+            `;
+            chatHistory.insertAdjacentHTML('beforeend', loadingHtml);
+            scrollToBottom();
+
+            // 3. Backend Integration for RAG Chat
+            try {
+                // Call the actual backend endpoint (e.g., /api/chat)
+                const res = await fetch(`${API_BASE}/chat`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ company: currentCompany, query: message })
+                });
+
+                if (document.getElementById(loaderId)) {
+                    document.getElementById(loaderId).remove();
+                }
+
+                if (!res.ok) {
+                    throw new Error('Failed to fetch response from RAG engine');
+                }
+
+                const data = await res.json();
+                
+                const botHtml = `
+                    <div class="flex flex-col gap-1 items-start chat-bubble">
+                        <div class="bg-slate-100 dark:bg-slate-800/60 text-slate-800 dark:text-slate-200 px-4 py-3 rounded-2xl rounded-tl-sm text-sm max-w-[85%] border border-slate-200 dark:border-white/5">
+                            ${data.answer || data.reply || data.message || "I found the relevant documents, but couldn't generate a summary."}
+                        </div>
+                        <span class="text-[10px] text-slate-400 font-mono ml-1 flex items-center gap-1">
+                            <svg class="w-3 h-3 text-pt-accent" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"></path></svg> RAG Engine
+                        </span>
+                    </div>
+                `;
+                chatHistory.insertAdjacentHTML('beforeend', botHtml);
+                scrollToBottom();
+                
+            } catch (error) {
+                console.error("Chat Error:", error);
+                
+                if (document.getElementById(loaderId)) {
+                    document.getElementById(loaderId).remove();
+                }
+                
+                // Fallback error UI if endpoint is not connected yet
+                const errorHtml = `
+                    <div class="flex flex-col gap-1 items-start chat-bubble">
+                        <div class="bg-rose-50 dark:bg-rose-900/20 text-rose-600 dark:text-rose-400 px-4 py-3 rounded-2xl rounded-tl-sm text-sm max-w-[85%] border border-rose-200 dark:border-rose-500/20">
+                            <strong>Connection Error:</strong> Backend /api/chat endpoint not found or unreachable. Please ensure the Flask route is implemented.
+                        </div>
+                        <span class="text-[10px] text-slate-400 font-mono ml-1">System Error</span>
+                    </div>
+                `;
+                chatHistory.insertAdjacentHTML('beforeend', errorHtml);
+                scrollToBottom();
+            }
+        });
+
+        function scrollToBottom() {
+            chatHistory.scrollTop = chatHistory.scrollHeight;
+        }
+
+        // --- Data Population ---
+        function populatePanel(d) {
+            // Header
+            document.getElementById('panel-company-name').textContent = d.company || 'Unknown';
+            document.getElementById('panel-source').textContent = d.source_label || 'Comprehensive Analysis';
+            
+            // Verdict Badge
+            const verdictEl = document.getElementById('panel-verdict');
+            const v = (d.verdict || 'Mixed').toUpperCase();
+            verdictEl.textContent = v;
+            verdictEl.className = 'px-3 py-1 rounded-full text-xs font-bold uppercase tracking-wider border ';
+            if (v === 'POSITIVE') verdictEl.classList.add('bg-emerald-100', 'dark:bg-emerald-500/20', 'text-emerald-700', 'dark:text-emerald-400', 'border-emerald-200', 'dark:border-emerald-500/30');
+            else if (v === 'NEGATIVE') verdictEl.classList.add('bg-rose-100', 'dark:bg-rose-500/20', 'text-rose-700', 'dark:text-rose-400', 'border-rose-200', 'dark:border-rose-500/30');
+            else verdictEl.classList.add('bg-amber-100', 'dark:bg-amber-500/20', 'text-amber-700', 'dark:text-amber-400', 'border-amber-200', 'dark:border-amber-500/30');
+
+
+            // RAG Explanation
+            const expEl = document.getElementById('panel-explanation');
+            if (d.explanation) {
+                let html = d.explanation.replace(/\*\*(.*?)\*\*/g, '<strong class="text-slate-900 dark:text-white font-semibold">$1</strong>');
+                html = html.replace(/\n/g, '<br/>');
+                expEl.innerHTML = `<p>${html}</p>`;
+            } else {
+                expEl.innerHTML = '<p class="text-slate-500 italic">No explanation generated.</p>';
+            }
+
+            // Signals
+            const renderSignal = (s, isPos) => `
+                <div class="flex gap-3 text-sm">
+                    <span class="font-mono text-xs px-1.5 py-0.5 rounded flex-shrink-0 self-start ${isPos ? 'bg-emerald-100 dark:bg-emerald-500/10 text-emerald-700 dark:text-emerald-400 border border-emerald-200 dark:border-emerald-500/20' : 'bg-rose-100 dark:bg-rose-500/10 text-rose-700 dark:text-rose-400 border border-rose-200 dark:border-rose-500/20'}">${s.index}</span>
+                    <div>
+                        <strong class="block text-slate-800 dark:text-slate-200 mb-1">${s.title}</strong>
+                        <span class="text-slate-600 dark:text-slate-400">${s.body}</span>
+                    </div>
+                </div>`;
+            
+            document.getElementById('panel-positive').innerHTML = d.positive_signals?.length 
+                ? d.positive_signals.map(s => renderSignal(s, true)).join('') 
+                : '<p class="text-slate-500 text-sm italic">No positive signals detected.</p>';
+                
+            document.getElementById('panel-negative').innerHTML = d.negative_signals?.length 
+                ? d.negative_signals.map(s => renderSignal(s, false)).join('') 
+                : '<p class="text-slate-500 text-sm italic">No negative signals detected.</p>';
+
+            // Metrics Grid
+            const metricsEl = document.getElementById('panel-metrics');
+            if (d.metrics && d.metrics.length) {
+                const trendIcon = { up: '↗', down: '↘', flat: '→' };
+                const trendColor = { up: 'text-emerald-600 dark:text-emerald-400', down: 'text-rose-600 dark:text-rose-400', flat: 'text-slate-500 dark:text-slate-400' };
+                
+                metricsEl.innerHTML = d.metrics.map(m => `
+                    <div class="bg-white dark:bg-slate-900/40 border border-slate-200 dark:border-white/5 rounded-2xl p-4 flex flex-col justify-between shadow-sm">
+                        <span class="text-xs font-mono text-slate-500 dark:text-slate-400 uppercase">${m.label}</span>
+                        <div class="mt-2 flex items-end justify-between">
+                            <span class="text-2xl font-serif text-slate-900 dark:text-white">${m.value}</span>
+                            <div class="flex flex-col items-end">
+                                <span class="text-xs ${trendColor[m.trend]} font-bold flex items-center gap-1">${trendIcon[m.trend]} ${m.trend.toUpperCase()}</span>
+                                <span class="text-[10px] text-slate-500">${m.sub}</span>
+                            </div>
+                        </div>
+                    </div>
+                `).join('');
+            } else {
+                metricsEl.innerHTML = '<p class="text-slate-500 text-sm italic">No financial metrics available.</p>';
+            }
+
+            // Bar Metrics
+            const barsEl = document.getElementById('panel-bar-metrics');
+            if (d.bar_metrics && d.bar_metrics.length) {
+                barsEl.innerHTML = d.bar_metrics.map((b, i) => `
+                    <div>
+                        <div class="flex justify-between text-xs mb-1">
+                            <span class="text-slate-600 dark:text-slate-300">${b.label}</span>
+                            <span class="font-mono text-slate-900 dark:text-white">${b.value}</span>
+                        </div>
+                        <div class="w-full bg-slate-200 dark:bg-slate-800 rounded-full h-2 overflow-hidden">
+                            <div class="h-full rounded-full transition-all duration-1000 ease-out" style="width: 0%; background-color: ${b.color}" data-width="${b.target_pct}%"></div>
+                        </div>
+                    </div>
+                `).join('');
+                
+                // Animate bars after a short delay
+                setTimeout(() => {
+                    barsEl.querySelectorAll('[data-width]').forEach(bar => {
+                        bar.style.width = bar.getAttribute('data-width');
+                    });
+                }, 100);
+            } else {
+                barsEl.innerHTML = '<p class="text-slate-500 text-sm italic">No QoQ data available.</p>';
+            }
+
+            // Claims Table
+            const claimsEl = document.getElementById('panel-claims');
+            if (d.claims && d.claims.length) {
+                const getDirHtml = (dir) => {
+                    if (dir === 'increase') return '<span class="text-emerald-600 dark:text-emerald-400 font-bold">↑ INC</span>';
+                    if (dir === 'decrease') return '<span class="text-rose-600 dark:text-rose-400 font-bold">↓ DEC</span>';
+                    return '<span class="text-slate-500 dark:text-slate-400 font-bold">→ FLAT</span>';
+                };
+                
+                const getResHtml = (res) => {
+                    const r = (res || '').toUpperCase();
+                    if (r === 'VERIFIED') return '<span class="px-2 py-1 bg-emerald-100 dark:bg-emerald-500/10 text-emerald-700 dark:text-emerald-400 border border-emerald-200 dark:border-emerald-500/20 rounded text-xs">Verified</span>';
+                    if (r === 'NOT VERIFIED' || r === 'FAILED') return '<span class="px-2 py-1 bg-rose-100 dark:bg-rose-500/10 text-rose-700 dark:text-rose-400 border border-rose-200 dark:border-rose-500/20 rounded text-xs">Failed</span>';
+                    if (r === 'PARTIAL') return '<span class="px-2 py-1 bg-amber-100 dark:bg-amber-500/10 text-amber-700 dark:text-amber-400 border border-amber-200 dark:border-amber-500/20 rounded text-xs">Partial</span>';
+                    return `<span class="px-2 py-1 bg-slate-200 dark:bg-slate-500/10 text-slate-700 dark:text-slate-400 border border-slate-300 dark:border-slate-500/20 rounded text-xs">${r || 'UNKNOWN'}</span>`;
+                };
+
+                claimsEl.innerHTML = d.claims.map(c => `
+                    <tr class="hover:bg-slate-50 dark:hover:bg-white/[0.02] transition-colors">
+                        <td class="px-6 py-4 font-mono text-xs text-slate-500 dark:text-slate-400 border-b border-slate-100 dark:border-white/5">${c.quarter || '--'}</td>
+                        <td class="px-6 py-4 whitespace-normal max-w-md border-b border-slate-100 dark:border-white/5">
+                            <p class="text-sm text-slate-800 dark:text-slate-200 line-clamp-2" title="${c.sentence}">${c.sentence}</p>
+                        </td>
+                        <td class="px-6 py-4 border-b border-slate-100 dark:border-white/5">
+                            <span class="px-2 py-1 bg-slate-100 dark:bg-white/5 border border-slate-200 dark:border-white/10 rounded text-xs text-slate-600 dark:text-slate-300 font-mono">${c.metric || 'N/A'}</span>
+                        </td>
+                        <td class="px-6 py-4 font-mono text-xs border-b border-slate-100 dark:border-white/5">${getDirHtml(c.direction)}</td>
+                        <td class="px-6 py-4 font-mono border-b border-slate-100 dark:border-white/5">${getResHtml(c.result)}</td>
+                    </tr>
+                `).join('');
+            } else {
+                claimsEl.innerHTML = `<tr><td colspan="5" class="px-6 py-8 text-center text-slate-500 italic">No claims data extracted.</td></tr>`;
+            }
+        }
+
+        // --- Loader Utility ---
+        function showLoader() {
+            loader.style.display = 'flex';
+            
+            const sequence = ['Aggregating RAG intelligence...', 'Analyzing DistilBERT claims...', 'Verifying financial outcomes...'];
+            let msgIndex = 0;
+            loaderStatus.textContent = sequence[0];
+            
+            window.loaderInterval = setInterval(() => {
+                msgIndex = (msgIndex + 1) % sequence.length;
+                loaderStatus.textContent = sequence[msgIndex];
+            }, 800);
+            
+            setTimeout(() => {
+                loader.classList.remove('hidden');
+                loader.classList.add('opacity-100');
+            }, 10);
+        }
+
+        function hideLoader() {
+            clearInterval(window.loaderInterval);
+            loader.classList.remove('opacity-100');
+            setTimeout(() => {
+                loader.classList.add('hidden');
+                loader.style.display = 'none';
+            }, 300);
+        }
+
+    </script>
+</body>
+</html>

chroma_db/589bdc22-9a2d-4c25-b432-0b35caad7759/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:200cb437a2ed2bf4c0160ba76ce7e5418aed10105ed04f03478116072089316b
+size 7066016

chroma_db/589bdc22-9a2d-4c25-b432-0b35caad7759/header.bin

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

chroma_db/589bdc22-9a2d-4c25-b432-0b35caad7759/index_metadata.pickle

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

chroma_db/589bdc22-9a2d-4c25-b432-0b35caad7759/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99708d3d149b9eabf69d9cb09e9f3666cf64a240e415aae996825bb71a55da93
+size 16864

chroma_db/589bdc22-9a2d-4c25-b432-0b35caad7759/link_lists.bin

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

chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f8e37238672bb8ae6a37afb3cc5d201436ec94c501f72933363c7e307782f6b
+size 10010624

claim_classification_model_distilbert_trained/claim_classifier_model/checkpoint-902/config.json

@@ -0,0 +1,28 @@
+{
+  "activation": "gelu",
+  "architectures": [
+    "DistilBertForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": null,
+  "dim": 768,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "eos_token_id": null,
+  "hidden_dim": 3072,
+  "initializer_range": 0.02,
+  "max_position_embeddings": 512,
+  "model_type": "distilbert",
+  "n_heads": 12,
+  "n_layers": 6,
+  "pad_token_id": 0,
+  "problem_type": "single_label_classification",
+  "qa_dropout": 0.1,
+  "seq_classif_dropout": 0.2,
+  "sinusoidal_pos_embds": false,
+  "tie_weights_": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "use_cache": false,
+  "vocab_size": 30522
+}

claim_classification_model_distilbert_trained/claim_classifier_model/checkpoint-902/model.safetensors

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

claim_classification_model_distilbert_trained/claim_classifier_model/checkpoint-902/tokenizer_config.json

@@ -0,0 +1,14 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "is_local": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "DistilBertTokenizer",
+  "unk_token": "[UNK]"
+}

claim_classification_model_distilbert_trained/claim_classifier_model/checkpoint-902/trainer_state.json

@@ -0,0 +1,184 @@
+{
+  "best_global_step": null,
+  "best_metric": null,
+  "best_model_checkpoint": null,
+  "epoch": 2.0,
+  "eval_steps": 500,
+  "global_step": 902,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.11086474501108648,
+      "grad_norm": 3.2481462955474854,
+      "learning_rate": 4.864190687361419e-05,
+      "loss": 0.5528812789916993,
+      "step": 50
+    },
+    {
+      "epoch": 0.22172949002217296,
+      "grad_norm": 4.128503322601318,
+      "learning_rate": 4.725609756097561e-05,
+      "loss": 0.3858406448364258,
+      "step": 100
+    },
+    {
+      "epoch": 0.3325942350332594,
+      "grad_norm": 6.555556297302246,
+      "learning_rate": 4.587028824833703e-05,
+      "loss": 0.377481575012207,
+      "step": 150
+    },
+    {
+      "epoch": 0.4434589800443459,
+      "grad_norm": 3.6121280193328857,
+      "learning_rate": 4.448447893569845e-05,
+      "loss": 0.3342946624755859,
+      "step": 200
+    },
+    {
+      "epoch": 0.5543237250554324,
+      "grad_norm": 6.620821952819824,
+      "learning_rate": 4.309866962305987e-05,
+      "loss": 0.3004466438293457,
+      "step": 250
+    },
+    {
+      "epoch": 0.6651884700665188,
+      "grad_norm": 3.3040060997009277,
+      "learning_rate": 4.171286031042129e-05,
+      "loss": 0.3366293716430664,
+      "step": 300
+    },
+    {
+      "epoch": 0.7760532150776053,
+      "grad_norm": 4.973900318145752,
+      "learning_rate": 4.0327050997782706e-05,
+      "loss": 0.2817412567138672,
+      "step": 350
+    },
+    {
+      "epoch": 0.8869179600886918,
+      "grad_norm": 5.162442684173584,
+      "learning_rate": 3.8941241685144125e-05,
+      "loss": 0.25218795776367187,
+      "step": 400
+    },
+    {
+      "epoch": 0.9977827050997783,
+      "grad_norm": 3.353585720062256,
+      "learning_rate": 3.7555432372505545e-05,
+      "loss": 0.27799144744873044,
+      "step": 450
+    },
+    {
+      "epoch": 1.0,
+      "eval_accuracy": 0.8829728230726567,
+      "eval_f1": 0.8908432488360062,
+      "eval_loss": 0.2983216941356659,
+      "eval_precision": 0.8351115421920465,
+      "eval_recall": 0.9545454545454546,
+      "eval_runtime": 3.5538,
+      "eval_samples_per_second": 507.338,
+      "eval_steps_per_second": 31.797,
+      "step": 451
+    },
+    {
+      "epoch": 1.1086474501108647,
+      "grad_norm": 3.653623342514038,
+      "learning_rate": 3.6169623059866964e-05,
+      "loss": 0.1536967372894287,
+      "step": 500
+    },
+    {
+      "epoch": 1.2195121951219512,
+      "grad_norm": 2.036006212234497,
+      "learning_rate": 3.478381374722838e-05,
+      "loss": 0.1598629665374756,
+      "step": 550
+    },
+    {
+      "epoch": 1.3303769401330376,
+      "grad_norm": 4.857279300689697,
+      "learning_rate": 3.33980044345898e-05,
+      "loss": 0.16571538925170898,
+      "step": 600
+    },
+    {
+      "epoch": 1.441241685144124,
+      "grad_norm": 3.656660556793213,
+      "learning_rate": 3.201219512195122e-05,
+      "loss": 0.15497909545898436,
+      "step": 650
+    },
+    {
+      "epoch": 1.5521064301552108,
+      "grad_norm": 0.165361687541008,
+      "learning_rate": 3.062638580931264e-05,
+      "loss": 0.15916526794433594,
+      "step": 700
+    },
+    {
+      "epoch": 1.6629711751662972,
+      "grad_norm": 4.209650039672852,
+      "learning_rate": 2.924057649667406e-05,
+      "loss": 0.1957833671569824,
+      "step": 750
+    },
+    {
+      "epoch": 1.7738359201773837,
+      "grad_norm": 6.54930305480957,
+      "learning_rate": 2.7854767184035478e-05,
+      "loss": 0.1656125259399414,
+      "step": 800
+    },
+    {
+      "epoch": 1.8847006651884701,
+      "grad_norm": 5.860881805419922,
+      "learning_rate": 2.64689578713969e-05,
+      "loss": 0.1518951988220215,
+      "step": 850
+    },
+    {
+      "epoch": 1.9955654101995566,
+      "grad_norm": 11.93374252319336,
+      "learning_rate": 2.508314855875832e-05,
+      "loss": 0.15036168098449706,
+      "step": 900
+    },
+    {
+      "epoch": 2.0,
+      "eval_accuracy": 0.9162506932889628,
+      "eval_f1": 0.9172602739726028,
+      "eval_loss": 0.2625793516635895,
+      "eval_precision": 0.9068255687973997,
+      "eval_recall": 0.9279379157427938,
+      "eval_runtime": 3.7906,
+      "eval_samples_per_second": 475.647,
+      "eval_steps_per_second": 29.81,
+      "step": 902
+    }
+  ],
+  "logging_steps": 50,
+  "max_steps": 1804,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 4,
+  "save_steps": 500,
+  "stateful_callbacks": {
+    "TrainerControl": {
+      "args": {
+        "should_epoch_stop": false,
+        "should_evaluate": false,
+        "should_log": false,
+        "should_save": true,
+        "should_training_stop": false
+      },
+      "attributes": {}
+    }
+  },
+  "total_flos": 252497609185452.0,
+  "train_batch_size": 16,
+  "trial_name": null,
+  "trial_params": null
+}

claim_classification_model_distilbert_trained/claim_classifier_model/checkpoint-902/training_args.bin

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

config.py

@@ -0,0 +1,52 @@
+"""
+config.py
+Single source of truth for all paths, model settings, and environment config.
+Import from here everywhere — never hardcode paths in pipeline files.
+"""
+ 
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+ 
+load_dotenv()
+ 
+# ── Directory layout ──────────────────────────────────────────────────────────
+ 
+BASE_DIR     = Path(__file__).resolve().parent
+DATA_DIR     = BASE_DIR / "data"
+FRONTEND_DIR = BASE_DIR / "frontend"
+CHROMA_DIR   = BASE_DIR / "chroma_db"
+ 
+# ── Model paths ───────────────────────────────────────────────────────────────
+ 
+MODEL_PATH = str(
+    BASE_DIR
+    / "claim_classification_model_distilbert_trained"
+    / "claim_classifier_model"
+    / "checkpoint-902"
+)
+ 
+# ── External API keys ─────────────────────────────────────────────────────────
+ 
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
+ 
+# ── Inference settings ────────────────────────────────────────────────────────
+ 
+CLAIM_MODEL_BATCH_SIZE = 64
+CLAIM_MODEL_THRESHOLD  = 0.6
+CLAIM_MODEL_MAX_LENGTH = 128
+ 
+# ── RAG settings ──────────────────────────────────────────────────────────────
+ 
+RAG_TOP_K         = 6
+CHROMA_DB_PATH    = str(CHROMA_DIR)
+CHROMA_COLLECTION = "claims"
+EMBEDDING_MODEL   = "all-MiniLM-L6-v2"
+GROQ_MODEL        = "llama-3.3-70b-versatile"
+ 
+# ── Flask settings ────────────────────────────────────────────────────────────
+ 
+DEBUG      = os.getenv("FLASK_DEBUG", "false").lower() == "true"
+HOST       = os.getenv("FLASK_HOST", "0.0.0.0")
+PORT       = int(os.getenv("FLASK_PORT", 5000))
+SECRET_KEY = os.getenv("SECRET_KEY", "dev-secret-change-in-prod")

db.py

@@ -0,0 +1,101 @@
+"""
+db.py
+SQLite database setup. Single source of truth for schema and connection.
+All tables are created here on first run — import get_db() everywhere else.
+"""
+
+import sqlite3
+from pathlib import Path
+from contextlib import contextmanager
+
+import config
+
+DB_PATH = Path(config.BASE_DIR) / "promisetrack.db"
+
+
+def init_db() -> None:
+    """Create all tables if they don't exist. Call once in create_app()."""
+    with get_db() as conn:
+        conn.executescript("""
+        CREATE TABLE IF NOT EXISTS companies (
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            folder_name  TEXT    UNIQUE NOT NULL,
+            display_name TEXT    NOT NULL,
+            status       TEXT    NOT NULL DEFAULT 'pending',
+            processed_at TIMESTAMP,
+            error_msg    TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS analysis_cache (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            company_id  INTEGER NOT NULL REFERENCES companies(id),
+            mode        TEXT    NOT NULL,
+            result_json TEXT    NOT NULL,
+            created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(company_id, mode)
+        );
+
+        CREATE TABLE IF NOT EXISTS claims (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            company_id    INTEGER NOT NULL REFERENCES companies(id),
+            quarter       TEXT,
+            sentence      TEXT,
+            metric        TEXT,
+            direction     TEXT,
+            magnitude     TEXT,
+            result        TEXT,
+            actual_change REAL,
+            confidence    REAL
+        );
+
+        CREATE TABLE IF NOT EXISTS timeseries (
+            id                          INTEGER PRIMARY KEY AUTOINCREMENT,
+            company_id                  INTEGER NOT NULL REFERENCES companies(id),
+            quarter                     TEXT,
+            revenue                     REAL,
+            net_profit                  REAL,
+            operating_profit            REAL,
+            profit_margin               REAL,
+            revenue_qoq_change          REAL,
+            net_profit_qoq_change       REAL,
+            operating_profit_qoq_change REAL,
+            profit_margin_qoq_change    REAL,
+            revenue_yoy_change          REAL,
+            net_profit_yoy_change       REAL,
+            operating_profit_yoy_change REAL,
+            profit_margin_yoy_change    REAL,
+            UNIQUE(company_id, quarter)
+        );
+
+        CREATE TABLE IF NOT EXISTS risk (
+            id                      INTEGER PRIMARY KEY AUTOINCREMENT,
+            company_id              INTEGER NOT NULL REFERENCES companies(id),
+            quarter                 TEXT,
+            total_claims            INTEGER,
+            verification_rate       REAL,
+            failure_rate            REAL,
+            partial_rate            REAL,
+            direction_mismatch_rate REAL,
+            consistency_score       REAL,
+            risk_drift              REAL,
+            warning_flag            INTEGER,
+            UNIQUE(company_id, quarter)
+        );
+        """)
+
+
+@contextmanager
+def get_db():
+    """Context manager that yields a SQLite connection with row_factory set."""
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")   # safe for concurrent reads
+    conn.execute("PRAGMA foreign_keys=ON")
+    try:
+        yield conn
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()

pipelines/finance/extract_xbrl_data.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+extract_xbrl_data.py
+Extracts XBRL/XML financial data from year-subfolder structure.
+Handles: CompanyName / YearFolder / *.xml
+"""
+
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Optional
+
+METRIC_MAPPING = {
+    "RevenueFromOperations": "revenue", "Revenue": "revenue",
+    "Income": "revenue", "TotalIncome": "revenue",
+    "ProfitLossForPeriod": "net_profit",
+    "ProfitLossFromOrdinaryActivitiesAfterTax": "net_profit",
+    "ProfitLossForPeriodFromContinuingOperations": "net_profit",
+    "OperatingProfitBeforeProvisionAndContingencies": "operating_profit",
+    "OperatingProfit": "operating_profit",
+    "ProfitBeforeTax": "operating_profit",
+    "ProfitBeforeExceptionalItemsAndTax": "operating_profit",
+    "ProfitBeforeTaxAndExceptionalItems": "operating_profit",
+    "Expenses": "total_expenses", "OperatingExpenses": "total_expenses",
+    "ExpenditureExcludingProvisionsAndContingencies": "total_expenses",
+    "TaxExpense": "tax_expense",
+    "BasicEarningsPerShareAfterExtraordinaryItems": "eps",
+}
+
+# Tags that should NEVER be mapped to revenue even if they fuzzy-match "income".
+# OtherIncome is a sub-component, not total revenue.
+_REVENUE_BLOCKLIST = {
+    "OtherIncome", "InterestEarned", "InterestOrDiscountOnAdvancesOrBills",
+    "RevenueOnInvestments", "InterestOnBalancesWithReserveBankOfIndiaAndOtherInterBankFunds",
+    "OtherInterest",
+}
+
+# Priority order for revenue: higher number = preferred when multiple tags map to "revenue".
+# Only the highest-priority tag seen per (company, quarter, metric) is kept.
+_METRIC_PRIORITY = {
+    "revenue": {
+        "Income": 100, "TotalIncome": 100,
+        "RevenueFromOperations": 90, "Revenue": 90,
+    },
+    "net_profit": {
+        "ProfitLossFromOrdinaryActivitiesAfterTax": 100,
+        "ProfitLossForPeriod": 90,
+        "ProfitLossForPeriodFromContinuingOperations": 80,
+    },
+    "operating_profit": {
+        "OperatingProfitBeforeProvisionAndContingencies": 100,
+        "OperatingProfit": 90,
+        "ProfitBeforeExceptionalItemsAndTax": 80,
+        "ProfitBeforeTaxAndExceptionalItems": 80,
+        "ProfitBeforeTax": 70,
+    },
+}
+
+
+def _parse_year_from_folder(folder_name: str) -> Optional[int]:
+    m = re.search(r'(\d{2})-(\d{2})', folder_name)
+    if m:
+        return 2000 + int(m.group(2))
+    m = re.search(r'[_\s](\d{2,4})$', folder_name)
+    if m:
+        y = int(m.group(1))
+        return y if y > 2000 else 2000 + y
+    m = re.search(r'(20\d{2})', folder_name)
+    if m:
+        return int(m.group(1))
+    return None
+
+
+def _assign_weights(year_folders: list) -> dict:
+    sorted_f = sorted(year_folders, key=lambda x: x[1], reverse=True)
+    return {folder: round(max(1.0 - rank * 0.25, 0.1), 2)
+            for rank, (folder, _) in enumerate(sorted_f)}
+
+
+def _quarter_from_context(root, context_id: str) -> Optional[str]:
+    try:
+        context = root.find(f".//*[@id='{context_id}']")
+        if context is None:
+            return None
+        period = context.find("{http://www.xbrl.org/2003/instance}period")
+        if period is None:
+            return None
+        
+        start_date = period.find("{http://www.xbrl.org/2003/instance}startDate")
+        end_date = period.find("{http://www.xbrl.org/2003/instance}endDate")
+        instant  = period.find("{http://www.xbrl.org/2003/instance}instant")
+        
+        # Ignore cumulative/YTD data (e.g., 9 months, 6 months). We only want ~90 day quarters.
+        if start_date is not None and end_date is not None and start_date.text and end_date.text:
+            from datetime import datetime
+            try:
+                sd = datetime.strptime(start_date.text, "%Y-%m-%d")
+                ed = datetime.strptime(end_date.text, "%Y-%m-%d")
+                days = (ed - sd).days
+                if days > 105: # Skip periods longer than a quarter
+                    return None
+            except Exception:
+                pass
+
+        node = end_date if end_date is not None else instant
+        if node is None or not node.text:
+            return None
+        m = re.match(r"(\d{4})-(\d{2})-\d{2}", node.text)
+        if not m:
+            return None
+            
+        year, month = int(m.group(1)), int(m.group(2))
+        
+        # ── FIX: Indian Financial Year Math ──
+        # If the calendar month is Jan-Mar, the FY matches the calendar year.
+        # If the calendar month is Apr-Dec, the FY is the NEXT calendar year.
+        fy_year = year if month <= 3 else year + 1
+        q = 4 if month <= 3 else (1 if month <= 6 else (2 if month <= 9 else 3))
+        
+        return f"{fy_year}-Q{q}"
+        
+    except Exception:
+        return None
+
+
+def _normalize_metric(tag: str) -> Optional[str]:
+    clean = tag.split("}")[-1] if "}" in tag else tag.split(":")[-1]
+    # Exact match first
+    if clean in METRIC_MAPPING:
+        # Block sub-components that fuzzy-match revenue but aren't total revenue
+        if clean in _REVENUE_BLOCKLIST:
+            return None
+        return METRIC_MAPPING[clean]
+    # Fuzzy match — but never let blocklisted tags through
+    if clean in _REVENUE_BLOCKLIST:
+        return None
+    for key, val in METRIC_MAPPING.items():
+        if key.lower() in clean.lower():
+            return val
+    return None
+
+
+def _tag_priority(clean_tag: str, metric: str) -> int:
+    """Return priority score for a tag within its metric group. Higher = preferred."""
+    return _METRIC_PRIORITY.get(metric, {}).get(clean_tag, 50)
+
+
+def _is_segment(context_id: str) -> bool:
+    return any(x in context_id.lower()
+               for x in ["segment", "reportablesegment", "geographicsegment"])
+
+
+def extract_numeric_data(xml_path: Path, company_name: str,
+                          weight: float = 1.0) -> list:
+    try:
+        root = ET.parse(xml_path).getroot()
+    except Exception:
+        return []
+
+    # best[(quarter, metric)] = {"value": ..., "priority": ..., "weight": ...}
+    best: dict = {}
+
+    for elem in root.iter():
+        if not (elem.get("unitRef") and elem.get("contextRef") and elem.text):
+            continue
+        try:
+            value = float(elem.text)
+        except (ValueError, TypeError):
+            continue
+        if abs(value) < 1:
+            continue
+        ctx = elem.get("contextRef")
+        if _is_segment(ctx):
+            continue
+        quarter = _quarter_from_context(root, ctx)
+        if not quarter:
+            continue
+        metric = _normalize_metric(elem.tag)
+        if not metric:
+            continue
+        if abs(value) > 1_000_000:
+            value = value / 10_000_000
+
+        clean_tag = elem.tag.split("}")[-1] if "}" in elem.tag else elem.tag.split(":")[-1]
+        priority = _tag_priority(clean_tag, metric)
+        key = (quarter, metric)
+
+        if key not in best or priority > best[key]["priority"]:
+            best[key] = {"value": round(value, 4), "priority": priority}
+
+    return [
+        {"company": company_name, "quarter": q, "metric": m,
+         "value": v["value"], "weight": weight}
+        for (q, m), v in best.items()
+    ]
+
+
+def run_xbrl_extraction_pipeline(companies_dir_path: str) -> list:
+    """
+    Scans: companies_dir/<Company>/<YearFolder>/*.xml
+    Assigns recency weights same as text pipeline.
+    """
+    companies_dir = Path(companies_dir_path)
+    if not companies_dir.exists():
+        raise FileNotFoundError(f"Not found: {companies_dir}")
+
+    all_records = []
+    for company_dir in sorted(companies_dir.iterdir()):
+        if not company_dir.is_dir():
+            continue
+        company_name = company_dir.name
+
+        year_folders = []
+        for sub in company_dir.iterdir():
+            if not sub.is_dir():
+                continue
+            year = _parse_year_from_folder(sub.name)
+            if year:
+                year_folders.append((sub, year))
+        if not year_folders:
+            year_folders = [(company_dir, 2024)]
+
+        weight_map = _assign_weights(year_folders)
+
+        for folder, year in year_folders:
+            weight = weight_map.get(folder, 0.1)
+            for xml_file in sorted(folder.glob("*.xml")):
+                records = extract_numeric_data(xml_file, company_name, weight)
+                all_records.extend(records)
+
+    # Deduplicate
+    seen, unique = set(), []
+    for r in all_records:
+        key = (r["company"], r["quarter"], r["metric"], r["value"])
+        if key not in seen:
+            unique.append(r)
+            seen.add(key)
+    unique.sort(key=lambda r: (r["company"], r["quarter"], r["metric"]))
+    return unique

pipelines/finance/prepare_timeseries_data.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""
+prepare_timeseries_data.py
+Builds a wide time-series DataFrame from raw XBRL numeric records,
+adding QoQ / YoY change features and profit margin.
+ 
+Flask entry point: run_timeseries_pipeline(xbrl_records)
+"""
+ 
+import numpy as np
+import pandas as pd
+ 
+ 
+# ── Config ────────────────────────────────────────────────────────────────────
+ 
+KEY_METRICS = {
+    "revenue":          ["revenue", "total_income"],
+    "net_profit":       ["net_profit", "profit_after_tax"],
+    "operating_profit": ["operating_profit"],
+}
+ 
+_FEATURE_COLS = ["revenue", "net_profit", "operating_profit", "profit_margin"]
+ 
+ 
+# ── Helpers ───────────────────────────────────────────────────────────────────
+ 
+def _sort_key(q: str) -> tuple:
+    try:
+        year, qn = q.split("-Q")
+        return (int(year), int(qn))
+    except Exception:
+        return (0, 0)
+ 
+def _safe_pct_change(series: pd.Series) -> pd.Series:
+    return (series - series.shift(1)) / series.shift(1) * 100
+ 
+ 
+# ── Flask entry point ─────────────────────────────────────────────────────────
+ 
+def run_timeseries_pipeline(xbrl_records: list[dict]) -> list[dict]:
+    """
+    Main entry point for the Flask app.
+ 
+    Input : list[dict] from run_xbrl_extraction_pipeline()
+            Keys: company, quarter, metric, value
+    Output: list[dict] — one row per (company, quarter) with derived
+            time-series features (QoQ, YoY, margin).
+    """
+    if not xbrl_records:
+        return []
+ 
+    df = pd.DataFrame(xbrl_records)
+ 
+    # ── Consolidate to wide format ────────────────────────────────────────────
+    records = []
+    for company in df["company"].unique():
+        cdf = df[df["company"] == company]
+        for quarter in cdf["quarter"].unique():
+            qdf = cdf[cdf["quarter"] == quarter]
+            row = {"company": company, "quarter": quarter}
+            for target, sources in KEY_METRICS.items():
+                val = None
+                for src in sources:
+                    subset = qdf[qdf["metric"] == src]
+                    if not subset.empty:
+                        # Use max to get the consolidated/total figure,
+                        # not a sub-component that may have snuck through.
+                        val = subset["value"].max()
+                        break
+                row[target] = val
+            records.append(row)
+ 
+    wide = pd.DataFrame(records)
+ 
+    # ── Sort chronologically ──────────────────────────────────────────────────
+    wide["_sort"] = wide["quarter"].apply(_sort_key)
+    wide = (
+        wide.sort_values(["company", "_sort"])
+            .drop(columns=["_sort"])
+            .reset_index(drop=True)
+    )
+ 
+    # ── Forward fill within each company ─────────────────────────────────────
+    wide = (
+        wide.groupby("company", group_keys=False)
+            .apply(lambda x: x.ffill())
+            .reset_index(drop=True)
+    )
+ 
+    # ── Derived metrics ───────────────────────────────────────────────────────
+    wide["profit_margin"] = wide["net_profit"] / wide["revenue"] * 100
+ 
+    # ── Time-series features (QoQ / YoY) ─────────────────────────────────────
+    for company in wide["company"].unique():
+        mask = wide["company"] == company
+        idx  = wide[mask].index
+        for col in _FEATURE_COLS:
+            values = pd.to_numeric(wide.loc[mask, col], errors="coerce")
+            wide.loc[idx, f"{col}_qoq_change"]     = _safe_pct_change(values)
+            wide.loc[idx, f"{col}_qoq_abs_change"]  = values.diff()
+            wide.loc[idx, f"{col}_yoy_change"]      = (
+                (values - values.shift(4)) / values.shift(4) * 100
+            )
+ 
+    # ── Drop all-NaN columns ──────────────────────────────────────────────────
+    wide = wide.dropna(how="all", axis=1)
+ 
+    return wide.to_dict(orient="records")
+ 

pipelines/finance/verify_claims.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+verify_claims.py
+Cross-references structured claim attributes against XBRL time-series data
+to verify whether each claim's stated direction is supported by the numbers.
+ 
+Flask entry point: run_claim_verification_pipeline(claim_records, timeseries_records)
+"""
+ 
+import re
+import pandas as pd
+ 
+ 
+# ── Metric mapping ────────────────────────────────────────────────────────────
+ 
+METRIC_COL = {
+    "revenue":    "revenue",
+    "profit":     "net_profit",
+    "ebitda":     "operating_profit",
+    "margin":     "profit_margin",
+    "expenses":   "total_expenses",
+    # proxy mappings
+    "subscriber": "revenue",
+    "order":      "revenue",
+    "deposit":    "revenue",
+    "loan":       "revenue",
+    "volume":     "revenue",
+    "arpu":       "revenue",
+    "return":     "profit_margin",
+    "provision":  "net_profit",
+}
+ 
+ 
+# ── Helpers ───────────────────────────────────────────────────────────────────
+ 
+def _normalise_quarter(q: str) -> str:
+    """Cleans quarter strings and converts Calendar Years to Indian FY."""
+    q = str(q).strip().upper()
+    year, quarter = None, None
+
+    m = re.search(r"([1-4])[Qq].*?(?:FY|20)?(\d{2,4})", q)
+    if not m: m = re.search(r"[Qq]([1-4]).*?(?:FY|20)?(\d{2,4})", q)
+    if not m:
+        m = re.match(r"^\d{4}-Q[1-4]$", q)
+        if m: year, quarter = int(q[:4]), int(q[-1])
+
+    if m and not year:
+        y_val = int(m.group(2))
+        year = y_val + 2000 if y_val < 100 else y_val
+        quarter = int(m.group(1))
+
+    if year and quarter:
+        if "FY" in q: return f"{year}-Q{quarter}"
+        # Indian FY Math: Apr-Dec (Q1, Q2, Q3) -> Next Year. Jan-Mar (Q4) -> Same Year.
+        fy_year = year + 1 if quarter in [1, 2, 3] else year
+        return f"{fy_year}-Q{quarter}"
+
+    return q
+ 
+def _infer_ref_type(sentence: str) -> str:
+    t = str(sentence).lower()
+    if "yoy" in t or "year" in t:
+        return "yoy"
+    return "qoq"
+ 
+ 
+def _evaluate(direction: str, change: float) -> tuple[str, str]:
+    if direction == "increase":
+        if change > 2:
+            return "VERIFIED",      "VERIFIED_STRONG"
+        if change < -2:
+            return "NOT VERIFIED",  "CONTRADICTS_DIRECTION"
+        return "PARTIAL",           "PARTIAL_NO_CHANGE"
+ 
+    if direction == "decrease":
+        if change < -2:
+            return "VERIFIED",      "VERIFIED_STRONG"
+        if change > 2:
+            return "NOT VERIFIED",  "CONTRADICTS_DIRECTION"
+        return "PARTIAL",           "PARTIAL_NO_CHANGE"
+ 
+    return "PARTIAL", "UNKNOWN_DIRECTION"
+ 
+ 
+def _get_nearest_row(ts_df: pd.DataFrame, company_key: str, quarter: str):
+    """
+    Returns (row, match_type). Tries exact match first, then falls back
+    to the previous quarter, then the latest available.
+    """
+    company_rows = ts_df[ts_df["_company_key"] == company_key]
+ 
+    if company_rows.empty:
+        return None, "NO_COMPANY_DATA"
+ 
+    exact = company_rows[company_rows["quarter"] == quarter]
+    if not exact.empty:
+        return exact.iloc[0], "EXACT_MATCH"
+ 
+    sorted_rows = company_rows.sort_values("quarter")
+    prev = sorted_rows[sorted_rows["quarter"] <= quarter]
+    if not prev.empty:
+        return prev.iloc[-1], "FALLBACK_PREV_QUARTER"
+ 
+    return sorted_rows.iloc[-1], "FALLBACK_LATEST"
+ 
+ 
+# ── Flask entry point ─────────────────────────────────────────────────────────
+ 
+def run_claim_verification_pipeline(
+    claim_records: list[dict],
+    timeseries_records: list[dict],
+) -> list[dict]:
+    """
+    Main entry point for the Flask app.
+ 
+    Input : claim_records       — from run_attribute_extraction_pipeline()
+                                  Keys: company, quarter, sentence, metric,
+                                        direction, magnitude, direction_missing
+            timeseries_records  — from run_timeseries_pipeline()
+                                  Keys: company, quarter, revenue, net_profit, ...
+    Output: list[dict] — one record per claim with verification result appended.
+            Added keys: actual_change, result, reason
+    """
+    if not claim_records or not timeseries_records:
+        return []
+ 
+    claims = pd.DataFrame(claim_records)
+    ts     = pd.DataFrame(timeseries_records)
+ 
+    claims["quarter"]      = claims["quarter"].apply(_normalise_quarter)
+    ts["quarter"]          = ts["quarter"].apply(_normalise_quarter)
+    ts["_company_key"]     = ts["company"].str.lower().str.strip()
+    claims["_company_key"] = claims["company"].str.lower().str.strip()
+ 
+    results = []
+ 
+    for _, row in claims.iterrows():
+        company_key = row["_company_key"]
+        quarter     = row["quarter"]
+        metric      = row["metric"]
+        direction   = str(row.get("direction", "")).lower()
+        sentence    = row.get("sentence", "")
+        base_col    = METRIC_COL.get(metric)
+ 
+        # Unknown metric
+        if not base_col or base_col not in ts.columns:
+            results.append({
+                **row.drop("_company_key").to_dict(),
+                "actual_change": None,
+                "result":        "SKIPPED",
+                "reason":        "MISSING_METRIC_MAPPING",
+            })
+            continue
+ 
+        ts_row, match_type = _get_nearest_row(ts, company_key, quarter)
+ 
+        if ts_row is None:
+            results.append({
+                **row.drop("_company_key").to_dict(),
+                "actual_change": None,
+                "result":        "SKIPPED",
+                "reason":        "MISSING_TS_ROW",
+            })
+            continue
+ 
+        # Resolve change column (YoY or QoQ, with QoQ fallback)
+        ref_type     = _infer_ref_type(sentence)
+        primary_col  = f"{base_col}_{ref_type}_change"
+        fallback_col = f"{base_col}_qoq_change"
+ 
+        actual_change = ts_row.get(primary_col)
+        fallback_used = False
+ 
+        if pd.isna(actual_change):
+            actual_change = ts_row.get(fallback_col)
+            fallback_used = True
+ 
+        if pd.isna(actual_change):
+            results.append({
+                **row.drop("_company_key").to_dict(),
+                "actual_change": None,
+                "result":        "SKIPPED",
+                "reason":        "MISSING_VALUE",
+            })
+            continue
+ 
+        result, reason = _evaluate(direction, float(actual_change))
+        tag = match_type + ("|FALLBACK_CHANGE" if fallback_used else "")
+ 
+        results.append({
+            **row.drop("_company_key").to_dict(),
+            "actual_change": round(float(actual_change), 2),
+            "result":        result,
+            "reason":        f"{reason} | {tag}",
+        })
+ 
+    return results

pipelines/ml/extract_attributes.py

@@ -0,0 +1,148 @@
+from typing import Optional
+#!/usr/bin/env python3
+"""
+extract_attributes.py
+Extracts structured attributes (metric, direction, magnitude) from claim sentences.
+
+Flask entry point: run_attribute_extraction_pipeline(claim_records)
+"""
+
+import re
+
+
+# ── Metric map ────────────────────────────────────────────────────────────────
+
+METRIC_MAP = [
+    ("ebitda",       ["ebitda"]),
+    ("revenue",      ["revenue", "sales", "turnover", "topline"]),
+    ("profit",       ["net profit", "profit", "pat", "pbt", "earnings"]),
+    ("margin",       ["margin", "ebitda margin", "operating margin"]),
+    ("expenses",     ["cost", "expense", "capex", "opex"]),
+    ("loan",         ["loan", "loan book", "credit", "advances"]),
+    ("deposit",      ["deposit", "casa"]),
+    ("npa",          ["npa", "gnpa", "nnpa"]),
+    ("arpu",         ["arpu"]),
+    ("aum",          ["aum"]),
+    ("volume",       ["volume"]),
+    ("subscriber",   ["subscriber", "user", "customer base"]),
+    ("order",        ["order", "order book", "backlog"]),
+    ("debt",         ["debt", "net debt"]),
+    ("cash_flow",    ["cash flow"]),
+    ("return",       ["roe", "roce", "roa"]),
+    ("provision",    ["provision"]),
+    ("market_share", ["market share"]),
+]
+
+# ── Direction patterns (data-driven) ─────────────────────────────────────────
+
+INCREASE_PATTERNS = r"(increase|growth|grew|improve|expanded|rise|higher|up|strong|robust|healthy|better)"
+DECREASE_PATTERNS = r"(decline|decrease|fall|drop|loss|pressure|weak|compression|down|impact)"
+NEUTRAL_PATTERNS  = r"(stable|steady|flat|maintain|unchanged)"
+
+# ── Magnitude ─────────────────────────────────────────────────────────────────
+
+_MAG_RE = re.compile(
+    r'(\d+(\.\d+)?\s*(%|bps|basis points|crore|million|billion|lakh))',
+    re.IGNORECASE,
+)
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _clean(s: str) -> str:
+    s = re.sub(r'[\r\n\t]+', ' ', s)
+    s = re.sub(r'\s+', ' ', s)
+    return s.strip().lower()
+
+def _split_sentence(s: str) -> list[str]:
+    """Split on contrast conjunctions only — NOT on 'and'."""
+    parts = re.split(r'\bbut\b|\bwhile\b|\bhowever\b', s)
+    return [p.strip() for p in parts if len(p.strip()) > 20]
+
+def extract_metrics(text: str) -> list[str]:
+    t = text.lower()
+    found = []
+    for name, kws in METRIC_MAP:
+        for kw in kws:
+            if kw in t:
+                found.append(name)
+                break
+    return list(set(found))
+
+def extract_direction(text: str, metric: str) -> Optional[str]:
+    t = text.lower()
+
+    # Global direction — decrease takes priority
+    if re.search(DECREASE_PATTERNS, t):
+        return "decrease"
+    if re.search(r"(increase|growth|grew|improve|expanded|rise|higher|up)", t):
+        return "increase"
+    # Soft positive → neutral
+    if re.search(r"(strong|robust|healthy|solid)", t):
+        return "neutral"
+    if re.search(NEUTRAL_PATTERNS, t):
+        return "neutral"
+
+    # Metric-local fallback
+    words = re.findall(r"[a-z]+", t)
+    metric_positions = [i for i, w in enumerate(words) if metric in w]
+    for pos in metric_positions:
+        window = " ".join(words[max(0, pos - 8) : pos + 8])
+        if re.search(DECREASE_PATTERNS, window):
+            return "decrease"
+        if re.search(INCREASE_PATTERNS, window):
+            return "increase"
+
+    return None
+
+def extract_magnitude(text: str) -> Optional[str]:
+    m = _MAG_RE.findall(text)
+    return m[0][0] if m else None
+
+
+# ── Flask entry point ─────────────────────────────────────────────────────────
+
+def run_attribute_extraction_pipeline(claim_records: list[dict]) -> list[dict]:
+    """
+    Main entry point for the Flask app.
+
+    Input : List of dicts from run_claim_extraction_pipeline(),
+            each must have: sentence, company, quarter
+    Output: List of dicts — one per (sentence-part × metric) combination.
+    """
+    records = []
+
+    for row in claim_records:
+        sentence = str(row.get("sentence", ""))
+
+        for part in _split_sentence(sentence):
+            clean_sent = _clean(part)
+            metrics    = extract_metrics(clean_sent)
+
+            if not metrics:
+                continue
+
+            magnitude = extract_magnitude(clean_sent)
+
+            for metric in metrics:
+                direction = extract_direction(clean_sent, metric)
+                records.append({
+                    "company":           row.get("company", ""),
+                    "quarter":           row.get("quarter", ""),
+                    "sentence":          part,
+                    "metric":            metric,
+                    "direction":         direction,
+                    "magnitude":         magnitude,
+                    "direction_missing": direction is None,
+                })
+
+    # Deduplicate on sentence + metric
+    seen = set()
+    unique = []
+    for r in records:
+        key = (r["sentence"], r["metric"])
+        if key not in seen:
+            unique.append(r)
+            seen.add(key)
+
+    return unique

pipelines/ml/merge_claim_dataset.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+merge_claim_dataset.py
+Merges claims + non-claims into a balanced, shuffled training dataset.
+ 
+Flask entry point: run_merge_dataset_pipeline(claim_records, non_claim_records)
+"""
+ 
+import pandas as pd
+ 
+ 
+def run_merge_dataset_pipeline(
+    claim_records: list[dict],
+    non_claim_records: list[dict],
+) -> list[dict]:
+    """
+    Main entry point for the Flask app.
+ 
+    Input : claim_records     — list of dicts with at least a 'sentence' key
+                                (from run_claim_extraction_pipeline())
+            non_claim_records — list of dicts with at least a 'sentence' key
+                                (from run_non_claim_extraction_pipeline())
+    Output: Deduplicated, shuffled list of dicts with keys: sentence, label.
+    """
+    claims             = pd.DataFrame(claim_records)
+    non_claims         = pd.DataFrame(non_claim_records)
+ 
+    claims["label"]     = "CLAIM"
+    non_claims["label"] = "NON_CLAIM"
+ 
+    df = pd.concat(
+        [claims[["sentence", "label"]], non_claims[["sentence", "label"]]],
+        ignore_index=True,
+    )
+ 
+    df = df.drop_duplicates(subset="sentence")
+    df = df.sample(frac=1, random_state=42).reset_index(drop=True)
+ 
+    return df.to_dict(orient="records")
+ 

pipelines/ml/non_claim_extractor.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+non_claim_extractor.py
+ 
+1. Removes sentences already identified as claims from the pool.
+2. Runs a lightweight second-pass keyword score on the remainder.
+3. Sentences scoring above threshold are rescued into claims
+   (catches what the spaCy pass missed).
+4. Samples the clean remainder to balance the dataset.
+ 
+Flask entry point: run_non_claim_extraction_pipeline(sentence_records, claim_records)
+"""
+"""
+import re
+import pandas as pd
+ 
+ 
+# ── Keyword sets for second-pass scoring ──────────────────────────────────────
+ 
+_PERF = {
+    "revenue", "revenues", "sales", "profit", "profits", "ebitda", "margin",
+    "margins", "income", "earnings", "growth", "decline", "volume", "volumes",
+    "cost", "costs", "loan", "loans", "deposit", "deposits", "credit",
+    "arpu", "aum", "subscriber", "subscribers", "customer", "customers",
+    "order", "orders", "capacity", "utilisation", "utilization", "share",
+    "contribution", "mix", "demand", "supply", "price", "pricing", "return",
+    "cash", "debt", "capex", "provision", "coverage", "ratio", "fee", "spread",
+    "collection", "disbursement", "addition", "base", "book", "output",
+}
+ 
+_DIR = {
+    "grew", "grow", "growth", "increase", "increased", "rise", "rose",
+    "improve", "improved", "improvement", "expand", "expanded", "expansion",
+    "decline", "declined", "decrease", "decreased", "fall", "fell", "drop",
+    "strong", "robust", "healthy", "solid", "stable", "steady", "record",
+    "higher", "lower", "better", "significant", "substantial", "momentum",
+    "recover", "recovered", "deliver", "delivered", "achieve", "achieved",
+    "surge", "surged", "jump", "jumped", "scale", "scaled", "accelerat",
+    "well", "good", "broad", "double", "triple", "outperform",
+}
+ 
+_NEGATION_RE   = re.compile(r"\b(not|no|never|don't|do not|didn't|did not|won't|will not)\b", re.IGNORECASE)
+_QUESTION_RE   = re.compile(r"\?$")
+_GARBAGE_RE    = re.compile(r"^[\d\s\.\,\%\|\-\(\)\$\₹\/\:]+$")
+_TRANSITION_RE = re.compile(
+    r"^(thank|thanks|good (morning|evening|afternoon)|hi |hello |"
+    r"let me (first|now|just)|moving on|turning to|coming to|over to|"
+    r"operator|moderator|so (let|shall) (me|us))",
+    re.IGNORECASE,
+)
+ 
+ 
+# ── Helpers ───────────────────────────────────────────────────────────────────
+ 
+def _dedup_key(s: str) -> str:
+    return re.sub(r"[^a-z0-9 ]", " ", re.sub(r"\s+", " ", str(s).lower())).strip()
+ 
+def keyword_score(sentence: str) -> int:
+    
+    s      = sentence.lower()
+    tokens = set(re.findall(r"[a-z]+", s))
+    perf_hits = sum(1 for kw in _PERF if kw in s)
+    dir_hits  = sum(1 for kw in _DIR  if any(t.startswith(kw) for t in tokens))
+    return perf_hits + dir_hits
+ 
+def is_likely_claim(sentence: str) -> bool:
+   
+    s = sentence.strip()
+    if len(s) < 25:
+        return False
+    if _QUESTION_RE.search(s) or _GARBAGE_RE.match(s) or _TRANSITION_RE.match(s):
+        return False
+    if _NEGATION_RE.search(s):
+        return False
+    return keyword_score(s) >= 3
+ 
+ 
+# ── Flask entry point ─────────────────────────────────────────────────────────
+ 
+def run_non_claim_extraction_pipeline(
+    sentence_records: list[dict],
+    claim_records: list[dict],
+) -> dict:
+    
+        
+    sentences_df = pd.DataFrame(sentence_records)
+    claims_df    = pd.DataFrame(claim_records)
+ 
+    # Build exclusion set from existing claims
+    claim_keys             = set(claims_df["sentence"].apply(_dedup_key))
+    sentences_df["_key"]   = sentences_df["sentence"].apply(_dedup_key)
+ 
+    remainder = (
+        sentences_df[~sentences_df["_key"].isin(claim_keys)]
+        .drop_duplicates("_key")
+        .copy()
+    )
+ 
+    # Second-pass: rescue missed claims from the remainder
+    rescued_mask = remainder["sentence"].apply(is_likely_claim)
+    rescued      = remainder[rescued_mask].drop(columns="_key")
+    true_non     = remainder[~rescued_mask].drop(columns="_key")
+ 
+    # Merge rescued into claims, deduplicate
+    all_claims_df = pd.concat([claims_df, rescued], ignore_index=True)
+    all_claims_df["_key"] = all_claims_df["sentence"].apply(_dedup_key)
+    all_claims_df = (
+        all_claims_df.drop_duplicates("_key")
+                     .drop(columns="_key")
+                     .reset_index(drop=True)
+    )
+ 
+    # Sample non-claims to match claim count (balanced dataset)
+    true_non  = true_non.drop_duplicates(subset="sentence")
+    n_sample  = min(len(all_claims_df), len(true_non))
+    non_claims_df = true_non.sample(n=n_sample, random_state=42).copy()
+    non_claims_df["label"] = "NON_CLAIM"
+ 
+    return {
+        "claims":     all_claims_df.to_dict(orient="records"),
+        "non_claims": non_claims_df.to_dict(orient="records"),
+    }
+"""
+    
+import re
+import torch
+import pandas as pd
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# Load FinBERT - specifically tuned for sentiment & claim-like financial tones
+# For a production agent, you'd use a local model to save on API costs
+MODEL_NAME = "ProsusAI/finbert"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
+
+def is_numeric_claim(sentence: str) -> bool:
+    """
+    Core logic: A financial claim must contain numeric proof 
+    (dates, percentages, currency, or counts).
+    """
+    # Regex for: $10M, 5%, 2026, 1.5bn, ₹500cr
+    numeric_pattern = r"(\d+\.?\d*)\s?([%m|bn|cr|k|%|₹|\$])"
+    return bool(re.search(numeric_pattern, sentence, re.IGNORECASE))
+
+def get_finbert_score(sentence: str):
+    """Uses Transformer to check if the sentence has a 'factual' or 'positive/negative' tone."""
+    inputs = tokenizer(sentence, return_tensors="pt", truncation=True, padding=True, max_length=128)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    
+    # 0: Positive, 1: Negative, 2: Neutral
+    # Claims are rarely 'Neutral'—they are usually driving a narrative (Pos/Neg)
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    conf, label = torch.max(probs, dim=-1)
+    return label.item(), conf.item()
+
+def run_non_claim_extraction_pipeline(sentence_records, claim_records):
+    """
+    Main entry point - same I/O as your old code, but with deep learning logic.
+    """
+    sentences_df = pd.DataFrame(sentence_records)
+    claims_df    = pd.DataFrame(claim_records)
+    
+    # 1. First Pass: Numerical Density Filter
+    # Most management claims contain a hard number (Numeric Drift Detection)
+    sentences_df["is_claim_candidate"] = sentences_df["sentence"].apply(is_numeric_claim)
+    
+    # 2. Second Pass: FinBERT Validation
+    # We only run the heavy transformer on candidates to save compute
+    def validate_claim(row):
+        if not row["is_claim_candidate"]:
+            return False
+        label, conf = get_finbert_score(row["sentence"])
+        # We accept sentences where FinBERT is confident it's NOT just neutral chatter
+        return label != 2 and conf > 0.85
+
+    sentences_df["is_verified_claim"] = sentences_df.apply(validate_claim, axis=1)
+    
+    claims_df = sentences_df[sentences_df["is_verified_claim"]].copy()
+    non_claims_df = sentences_df[~sentences_df["is_verified_claim"]].copy()
+    
+    # Labeling for your balanced dataset
+    claims_df["label"] = "CLAIM"
+    non_claims_df["label"] = "NON_CLAIM"
+    
+    # Balancing the dataset (Sample non-claims to match claims count)
+    n_sample = min(len(claims_df), len(non_claims_df))
+    balanced_non_claims = non_claims_df.sample(n=n_sample, random_state=42)
+    
+    return {
+        "claims": claims_df.to_dict(orient="records"),
+        "non_claims": balanced_non_claims.to_dict(orient="records")
+    }