init agentic demo test

README.md

@@ -0,0 +1,16 @@
+---
+title: DemoC Gradio Test
+emoji: 🤖
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+app_file: demo_c.py
+pinned: false
+---
+
+# DemoC Gradio Test
+
+## Run locally
+```bash
+pip install -r requirements.txt
+python demoC.py

app_backed.py

@@ -0,0 +1,1012 @@
+from __future__ import annotations
+
+"""
+FINAL DEMO (v10.2): Stable, runs locally + HF Spaces.
+
+Design goals (per your 5-step analyst workflow)
+- Output must always be non-empty and human-readable.
+- Trace tab must record: run_id / model_id / version_id / policy_id + 5 steps + tool_used per step.
+- NO LangGraph. NO LLM tool-calling.
+- FinTech:
+  - Python computes PD + confidence + HITL urgency (and optional model choice via LLM selector).
+  - Output includes explicit prediction + decision bullet.
+- TE Pricing:
+  - Primary: Python "pricing_heuristic" (value/segment/channel aware) so it won't stick to 42/52.
+  - Optional: LLM proposes a price range and adjustments (no browsing). If LLM fails, we still output a valid result.
+  - Hard constraints enforced in Python: presale >= max(7*COGS, mult*COGS), retail > presale.
+
+HF Spaces:
+- Rename to app.py
+- Set OPENAI_API_KEY in Space Secrets (optional for TE/FinTech explanation add-on, NOT required for base output)
+"""
+
+import json
+import math
+import os
+import sys
+import time
+import uuid
+import traceback
+from dataclasses import dataclass, asdict, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+# OpenAI is OPTIONAL (we never allow "no content" if API fails)
+try:
+    from openai import OpenAI
+except Exception:
+    OpenAI = None
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import roc_auc_score
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+
+
+print("\n========== FINAL_APP BOOT (v10.4) ==========")
+print("RUNNING_FILE =", __file__)
+print("CWD =", os.getcwd())
+print("PYTHON =", sys.executable)
+print("OPENAI_MODEL =", os.getenv("OPENAI_MODEL", "gpt-4o-mini"))
+print("OPENAI_API_KEY_SET =", "YES" if bool(os.getenv("OPENAI_API_KEY", "")) else "NO")
+print("===========================================\n")
+
+
+# =========================
+# Config
+# =========================
+APP_TITLE = "Demo C"
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+AGENT_ID = os.getenv("AGENT_ID", "nexdatawork_demo_agent")
+MODEL_ID = os.getenv("MODEL_ID", "python_5step_traceable")
+VERSION_ID = os.getenv("VERSION_ID", "10.4.0")
+
+POLICY_ID = os.getenv("POLICY_ID", "5step_traceable_policy")
+POLICY_VERSION = os.getenv("POLICY_VERSION", "10.4")
+
+DATA_DIR = Path(os.getenv("DATA_DIR", "./data"))
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+RUN_LOG_PATH = DATA_DIR / os.getenv("RUN_LOG_PATH", "run_logs.jsonl")
+
+DEFAULT_SYNTHETIC_SEED = 42
+HIGH_IMPACT_AMOUNT = float(os.getenv("HIGH_IMPACT_AMOUNT", "1000000"))
+
+
+# =========================
+# Helpers
+# =========================
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+def new_id(prefix: str) -> str:
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return f"{prefix}_{ts}_{uuid.uuid4().hex[:8]}"
+
+def clamp(x: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, x))
+
+def sigmoid(x: float) -> float:
+    if x >= 0:
+        z = math.exp(-x)
+        return 1.0 / (1.0 + z)
+    z = math.exp(x)
+    return z / (1.0 + z)
+
+def as_99(x: float) -> float:
+    v = round(float(x))
+    return float(f"{max(v, 1) - 0.01:.2f}")
+
+def run_metadata(task_type: str, thread_id: str) -> Dict[str, Any]:
+    return {
+        "run_id": new_id("run"),
+        "agent_id": AGENT_ID,
+        "model_id": MODEL_ID,
+        "version_id": VERSION_ID,
+        "policy_id": POLICY_ID,
+        "policy_version": POLICY_VERSION,
+        "llm_model": OPENAI_MODEL,
+        "task_type": task_type,
+        "thread_id": thread_id,
+        "timestamps": {"created_at": utc_now()},
+    }
+
+
+# =========================
+# JSONL Logger
+# =========================
+class JSONLLogger:
+    def __init__(self, path: Path):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def append(self, payload: Dict[str, Any]) -> None:
+        with self.path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+    def tail(self, n: int = 50) -> List[Dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        lines = self.path.read_text(encoding="utf-8").splitlines()
+        out: List[Dict[str, Any]] = []
+        for ln in lines[-n:]:
+            try:
+                out.append(json.loads(ln))
+            except Exception:
+                continue
+        return out
+
+LOGGER = JSONLLogger(RUN_LOG_PATH)
+
+
+# =========================
+# Trace structures
+# =========================
+@dataclass
+class StepTrace:
+    step_id: str
+    step_no: int
+    title: str
+    tool_used: str
+    started_at: str
+    ended_at: str
+    duration_ms: int
+    inputs: Dict[str, Any] = field(default_factory=dict)
+    outputs: Dict[str, Any] = field(default_factory=dict)
+    error: Optional[str] = None
+
+def run_step(step_no: int, title: str, tool_used: str, inputs: Dict[str, Any], fn) -> Tuple[StepTrace, Any]:
+    step_id = new_id("step")
+    started = utc_now()
+    t0 = time.time()
+    err = None
+    out = None
+    out_obj: Dict[str, Any] = {}
+    try:
+        out = fn()
+        if isinstance(out, dict):
+            out_obj = out
+        else:
+            out_obj = {"value": out}
+    except Exception:
+        err = traceback.format_exc()
+    ended = utc_now()
+    dur = int((time.time() - t0) * 1000)
+    return StepTrace(
+        step_id=step_id,
+        step_no=step_no,
+        title=title,
+        tool_used=tool_used,
+        started_at=started,
+        ended_at=ended,
+        duration_ms=dur,
+        inputs=inputs,
+        outputs=out_obj if err is None else {},
+        error=err,
+    ), out
+
+
+# =========================
+# Optional LLM helpers (never required)
+# =========================
+def _client_or_none():
+    if OpenAI is None:
+        return None
+    if not os.getenv("OPENAI_API_KEY", ""):
+        return None
+    try:
+        return OpenAI()
+    except Exception:
+        return None
+
+def llm_te_adjustment(client: Any, about: str, inputs: Dict[str, Any], base: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Optional: ask LLM for adjustment factor and competitor range.
+    Must not break if it fails.
+    """
+    prompt = {
+        "about": about,
+        "inputs": inputs,
+        "base": base,
+        "instruction": (
+            "No browsing. Return STRICT JSON: "
+            "{"
+            "\"adj_presale_delta\": number, "
+            "\"adj_retail_delta\": number, "
+            "\"competitor_range\": {\"low\": number, \"high\": number}, "
+            "\"confidence_0_100\": number, "
+            "\"rationale_bullets\": [..]"
+            "}. Keep bullets 4-7."
+        ),
+    }
+    try:
+        resp = client.chat.completions.create(
+            model=OPENAI_MODEL,
+            temperature=0.2,
+            messages=[
+                {"role": "system", "content": "Return STRICT JSON only. No markdown."},
+                {"role": "user", "content": json.dumps(prompt)},
+            ],
+        )
+        raw = (resp.choices[0].message.content or "").strip()
+        obj = json.loads(raw)
+        return {
+            "adj_presale_delta": float(obj.get("adj_presale_delta", 0.0)),
+            "adj_retail_delta": float(obj.get("adj_retail_delta", 0.0)),
+            "competitor_range": obj.get("competitor_range", {}) or {"low": 0.0, "high": 0.0},
+            "confidence_0_100": float(clamp(float(obj.get("confidence_0_100", 50.0)), 0.0, 100.0)),
+            "rationale_bullets": [str(x)[:200] for x in (obj.get("rationale_bullets", []) or [])][:10],
+            "raw": raw[:1400],
+        }
+    except Exception as e:
+        return {
+            "error": str(e)[:400],
+            "adj_presale_delta": 0.0,
+            "adj_retail_delta": 0.0,
+            "competitor_range": {"low": 0.0, "high": 0.0},
+            "confidence_0_100": 0.0,
+            "rationale_bullets": ["LLM adjustment unavailable (API missing or invalid JSON)."],
+        }
+
+
+# =========================
+# FinTech tools
+# =========================
+def fintech_build_row(inp: Dict[str, Any]) -> pd.DataFrame:
+    return pd.DataFrame([{
+        "Income": inp["income"],
+        "Debt": inp["debt"],
+        "Credit_Score": inp["credit_score"],
+        "Employment_Status": inp["employment_status"],
+        "Missed_Payments_12m": inp["missed_payments_12m"],
+        "Months_On_Book": inp["months_on_book"],
+        "Credit_Lines": inp["credit_lines"],
+        "Requested_Amount": inp["requested_amount"],
+        "Savings": inp["savings"],
+        "Collateral_Value": inp["collateral_value"],
+        "Fraud_Flag": inp["fraud_flag"],
+        "Existing_Customer": inp["existing_customer"],
+    }])
+
+def fintech_preprocess(df: pd.DataFrame) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    out = df.copy()
+    missing_before = out.isna().sum().astype(int).to_dict()
+    for col in out.columns:
+        if pd.api.types.is_numeric_dtype(out[col]):
+            if out[col].isna().any():
+                med = pd.to_numeric(out[col], errors="coerce").median()
+                out[col] = pd.to_numeric(out[col], errors="coerce").fillna(med)
+        else:
+            if out[col].isna().any():
+                out[col] = out[col].fillna("Unknown")
+    missing_after = out.isna().sum().astype(int).to_dict()
+    return out, {"missing_before": missing_before, "missing_after": missing_after}
+
+def fintech_features(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    income = out["Income"].clip(lower=1.0)
+    debt = out["Debt"].clip(lower=0.0)
+    savings = out["Savings"].clip(lower=0.0)
+    collateral = out["Collateral_Value"].clip(lower=0.0)
+    amount = out["Requested_Amount"].clip(lower=1.0)
+
+    out["DTI"] = (debt / income).clip(lower=0, upper=5)
+    out["Savings_to_Income"] = (savings / income).clip(lower=0, upper=5)
+    out["Collateral_to_Amount"] = (collateral / amount).clip(lower=0, upper=10)
+
+    out["Score_Gap"] = ((850 - out["Credit_Score"]) / 550).clip(lower=0, upper=1)
+    out["Missed_Norm"] = (out["Missed_Payments_12m"].clip(lower=0, upper=12) / 12.0)
+    out["Tenure_Norm"] = (out["Months_On_Book"].clip(lower=0, upper=120) / 120.0)
+    out["Lines_Norm"] = (out["Credit_Lines"].clip(lower=0, upper=20) / 20.0)
+
+    emp = out["Employment_Status"].astype(str).str.lower().str.strip()
+    emp_w = emp.map({
+        "employed": 0.00, "self-employed": 0.05, "student": 0.08,
+        "unemployed": 0.18, "retired": 0.04, "contract": 0.06, "other": 0.07
+    }).fillna(0.07)
+    out["Employment_Risk_Weight"] = emp_w
+
+    out["Fraud_Risk"] = out["Fraud_Flag"].astype(int).clip(0, 1)
+    out["Loyalty_Boost"] = out["Existing_Customer"].astype(int).clip(0, 1)
+    return out
+
+def fintech_tool_heuristic(df_feat: pd.DataFrame) -> Dict[str, Any]:
+    f = df_feat.iloc[0].to_dict()
+    x = (
+        -1.10
+        + 1.50 * f["DTI"]
+        + 1.20 * f["Score_Gap"]
+        + 0.95 * f["Missed_Norm"]
+        + 0.70 * f["Employment_Risk_Weight"]
+        - 0.35 * f["Tenure_Norm"]
+        - 0.25 * f["Lines_Norm"]
+        - 0.45 * f["Savings_to_Income"]
+        - 0.35 * f["Collateral_to_Amount"]
+        + 2.00 * f["Fraud_Risk"]
+        - 0.20 * f["Loyalty_Boost"]
+    )
+    pd_risk = sigmoid(float(x))
+    conf = float(clamp(abs(pd_risk - 0.5) * 200.0, 0.0, 100.0))
+    urg = float(clamp((100.0 - conf) * 0.75, 0.0, 100.0))
+    return {"tool": "heuristic", "pd_risk": pd_risk, "confidence_0_100": conf, "hitl_urgency_0_100": urg, "linear_x": float(x)}
+
+def _fintech_make_synth_training(seed: int = 42, n: int = 1500) -> pd.DataFrame:
+    rng = np.random.default_rng(seed)
+    income = rng.lognormal(mean=np.log(65000), sigma=0.55, size=n).clip(12000, 250000)
+    debt = rng.lognormal(mean=np.log(18000), sigma=0.75, size=n).clip(0, 200000)
+    score = rng.integers(300, 851, size=n)
+    missed = rng.integers(0, 7, size=n)
+    mob = rng.integers(0, 121, size=n)
+    lines = rng.integers(0, 21, size=n)
+    savings = rng.lognormal(mean=np.log(8000), sigma=0.9, size=n).clip(0, 200000)
+    collateral = rng.lognormal(mean=np.log(15000), sigma=0.9, size=n).clip(0, 300000)
+    fraud = rng.binomial(1, 0.03, size=n)
+    existing = rng.binomial(1, 0.55, size=n)
+    emp = rng.choice(["Employed","Self-employed","Student","Unemployed","Retired","Contract","Other"], size=n)
+    req_amount = rng.lognormal(mean=np.log(25000), sigma=0.8, size=n).clip(500, 250000)
+
+    df = pd.DataFrame({
+        "Income": income, "Debt": debt, "Credit_Score": score,
+        "Employment_Status": emp, "Missed_Payments_12m": missed,
+        "Months_On_Book": mob, "Credit_Lines": lines,
+        "Requested_Amount": req_amount,
+        "Savings": savings,
+        "Collateral_Value": collateral,
+        "Fraud_Flag": fraud,
+        "Existing_Customer": existing,
+    })
+    df_clean, _ = fintech_preprocess(df)
+    df_feat = fintech_features(df_clean)
+
+    x = (
+        -1.10
+        + 1.50 * df_feat["DTI"]
+        + 1.20 * df_feat["Score_Gap"]
+        + 0.95 * df_feat["Missed_Norm"]
+        + 0.70 * df_feat["Employment_Risk_Weight"]
+        - 0.35 * df_feat["Tenure_Norm"]
+        - 0.25 * df_feat["Lines_Norm"]
+        - 0.45 * df_feat["Savings_to_Income"]
+        - 0.35 * df_feat["Collateral_to_Amount"]
+        + 2.00 * df_feat["Fraud_Risk"]
+        - 0.20 * df_feat["Loyalty_Boost"]
+    )
+    p = 1 / (1 + np.exp(-x))
+    y = rng.binomial(1, p).astype(int)
+
+    df_feat = df_feat.copy()
+    df_feat["y"] = y
+    return df_feat
+
+def fintech_tool_logreg_synth(df_case_feat: pd.DataFrame, seed: int = 42) -> Dict[str, Any]:
+    train_df = _fintech_make_synth_training(seed=seed, n=1500)
+    cols = [
+        "DTI","Score_Gap","Missed_Norm","Tenure_Norm","Lines_Norm",
+        "Employment_Risk_Weight","Savings_to_Income","Collateral_to_Amount","Fraud_Risk","Loyalty_Boost"
+    ]
+    X = train_df[cols].astype(float)
+    y = train_df["y"].astype(int)
+
+    X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=seed, stratify=y)
+    model = LogisticRegression(max_iter=1000, solver="lbfgs")
+    model.fit(X_tr, y_tr)
+
+    auc = float(roc_auc_score(y_te, model.predict_proba(X_te)[:, 1]))
+    case_x = df_case_feat[cols].astype(float)
+
+    pd_risk = float(model.predict_proba(case_x)[:, 1][0])
+    conf = float(clamp(abs(pd_risk - 0.5) * 200.0, 0.0, 100.0))
+    urg = float(clamp((100.0 - conf) * 0.75, 0.0, 100.0))
+    return {"tool": "logreg_synth", "auc_test_synth": auc, "pd_risk": pd_risk, "confidence_0_100": conf, "hitl_urgency_0_100": urg}
+
+def fintech_tool_tree_synth(df_case_feat: pd.DataFrame, seed: int = 42) -> Dict[str, Any]:
+    train_df = _fintech_make_synth_training(seed=seed, n=1500)
+    cols = [
+        "DTI","Score_Gap","Missed_Norm","Tenure_Norm","Lines_Norm",
+        "Employment_Risk_Weight","Savings_to_Income","Collateral_to_Amount","Fraud_Risk","Loyalty_Boost"
+    ]
+    X = train_df[cols].astype(float)
+    y = train_df["y"].astype(int)
+
+    X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=seed, stratify=y)
+    model = DecisionTreeClassifier(max_depth=4, random_state=seed)
+    model.fit(X_tr, y_tr)
+
+    auc = float(roc_auc_score(y_te, model.predict_proba(X_te)[:, 1]))
+    case_x = df_case_feat[cols].astype(float)
+
+    pd_risk = float(model.predict_proba(case_x)[:, 1][0])
+    conf = float(clamp(abs(pd_risk - 0.5) * 200.0, 0.0, 100.0))
+    urg = float(clamp((100.0 - conf) * 0.75, 0.0, 100.0))
+    return {"tool": "tree_synth", "auc_test_synth": auc, "pd_risk": pd_risk, "confidence_0_100": conf, "hitl_urgency_0_100": urg}
+
+FINTECH_TOOL_REGISTRY = {
+    "heuristic": fintech_tool_heuristic,
+    "logreg_synth": fintech_tool_logreg_synth,
+    "tree_synth": fintech_tool_tree_synth,
+}
+
+def fintech_recommend(score: Dict[str, Any], requested_amount: float) -> Dict[str, Any]:
+    conf = float(score.get("confidence_0_100", 0.0))
+    urg = float(score.get("hitl_urgency_0_100", 100.0))
+    bump = 0.0
+    if HIGH_IMPACT_AMOUNT > 0 and requested_amount > 0:
+        ratio = requested_amount / HIGH_IMPACT_AMOUNT
+        bump = 20.0 * clamp(math.log10(ratio + 1.0) / math.log10(11.0), 0.0, 1.0)
+    urg2 = float(clamp(urg + bump, 0.0, 100.0))
+    decision = "Needs Human Review" if (urg2 >= 60.0 or conf <= 25.0) else "Decision Draft"
+    return {"decision": decision, "hitl_urgency_0_100": urg2, "prediction_pd": float(score.get("pd_risk", 0.5))}
+
+
+# =========================
+# TE pricing heuristic (PRIMARY)
+# =========================
+def te_pricing_heuristic(inp: Dict[str, Any]) -> Dict[str, Any]:
+    cogs = float(inp["cogs"])
+    landed = float(inp["landed"])
+    mult = float(inp["presale_mult"])
+    discount = float(inp["discount"])
+    channel = str(inp.get("channel", "DTC"))
+    segment = str(inp.get("target_segment", "Mid-market"))
+    units = int(inp.get("expected_presale_units", 0))
+
+    # User-friendly demand controls (0-100)
+    demand_index = float(inp.get("demand_index", 60.0))
+    price_sensitivity = float(inp.get("price_sensitivity", 60.0))
+    price_step = float(inp.get("price_step", 10.0))
+    demand_index = clamp(demand_index, 0.0, 100.0)
+    price_sensitivity = clamp(price_sensitivity, 0.0, 100.0)
+    price_step = max(1.0, float(price_step))
+
+    floor = max(7.0 * cogs, mult * cogs)
+
+    # segment anchor retail
+    # (pure heuristic so the AI demo doesn't get stuck at 42/52)
+    if segment.lower().startswith("budget"):
+        retail_anchor = 79.99
+    elif segment.lower().startswith("premium"):
+        retail_anchor = 149.99
+    else:
+        retail_anchor = 109.99
+
+    # channel adjustments
+    if channel.lower() == "amazon":
+        retail_anchor -= 10.0
+    elif channel.lower() == "retail":
+        retail_anchor += 10.0
+    elif channel.lower() == "wholesale":
+        retail_anchor -= 15.0
+
+    # volume signal: more units -> can accept slightly lower retail
+    if units >= 5000:
+        retail_anchor -= 8.0
+    elif units >= 2000:
+        retail_anchor -= 4.0
+    elif units > 0 and units < 300:
+        retail_anchor += 6.0
+
+    # Demand controls: higher demand_index supports higher willingness-to-pay; higher sensitivity pushes price down.
+    retail_anchor += (demand_index - 50.0) * 0.3  # up to about +/-15
+    retail_anchor -= (price_sensitivity - 50.0) * 0.2  # up to about +/-10
+
+    retail_floor_from_discount = floor / max(1e-6, (1.0 - discount))
+    retail = max(retail_anchor, retail_floor_from_discount)
+
+    presale = retail * (1.0 - discount)
+    presale = max(presale, floor)
+
+    presale = as_99(presale)
+    retail = as_99(retail)
+
+    # ensure retail>presale strictly
+    if retail <= presale:
+        retail = as_99(presale / max(1e-6, (1.0 - discount)))
+
+    checks = {
+        "presale_ge_7xcogs": presale >= 7.0 * cogs,
+        "presale_ge_floor": presale >= floor,
+        "retail_gt_presale": retail > presale,
+        "presale_gt_landed": presale > landed,
+        "retail_gt_landed": retail > landed,
+    }
+
+    return {
+        "tool": "pricing_heuristic",
+        "floor": floor,
+        "presale_price": presale,
+        "retail_price": retail,
+        "unit_margin_presale": float(presale - landed),
+        "unit_margin_retail": float(retail - landed),
+        "checks": checks,
+        "anchors": {"segment": segment, "channel": channel, "retail_anchor": retail_anchor, "units": units, "demand_index": demand_index, "price_sensitivity": price_sensitivity, "price_step": price_step},
+    }
+
+
+# =========================
+# 5-step explanation builder (Python, always non-empty)
+# =========================
+def build_5step_explanation_md(title: str, step_bullets: Dict[int, List[str]], evidence_md: str, prediction_bullet: str, decision_bullet: str) -> str:
+    md: List[str] = []
+    md.append("## Explanation")
+    # Use professional workflow section titles instead of "Step 1..5"
+    for i in range(1, 6):
+        section_title = FIVE_STEP_TITLES[i - 1]
+        md.append(f"### {section_title}")
+        blt = step_bullets.get(i, [])
+        if not blt:
+            blt = ["(no content)"]
+        for b in blt[:8]:
+            md.append(f"- {b}")
+    md.append("")
+    md.append("## Evidence")
+    md.append(evidence_md.strip() if evidence_md.strip() else "- (no evidence)")
+    md.append("")
+    md.append("## Prediction")
+    md.append(f"- {prediction_bullet}")
+    md.append("")
+    md.append("## Decision")
+    md.append(f"- {decision_bullet}")
+    return "\n".join(md).strip()
+
+
+# =========================
+# Workflows
+# =========================
+FIVE_STEP_TITLES = [
+    "Interpreting Context & Metrics (Questions + EDA)",
+    "Pre-Processing Data (Cleaning + Missing Values)",
+    "Processing Data (Transform + Feature Build)",
+    "Analyzing Data (Modeling + Scoring)",
+    "Trend Analysis & Predictions (Decision + Share)",
+]
+def run_fintech_workflow(thread_id: str, about: str, inp: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    meta = run_metadata("fintech", thread_id)
+    steps: List[StepTrace] = []
+
+    s1, _ = run_step(1, FIVE_STEP_TITLES[0], "context_capture", {"about_preview": about[:200]}, lambda: {"about_len": len(about)})
+    steps.append(s1)
+
+    df_raw = fintech_build_row(inp)
+    df_clean, prep = fintech_preprocess(df_raw)
+    s2, _ = run_step(2, FIVE_STEP_TITLES[1], "fintech_preprocess", {}, lambda: prep)
+    steps.append(s2)
+
+    df_feat = fintech_features(df_clean)
+    feat_preview = df_feat[[
+        "DTI","Score_Gap","Missed_Norm","Tenure_Norm","Lines_Norm",
+        "Savings_to_Income","Collateral_to_Amount","Fraud_Risk","Loyalty_Boost"
+    ]].iloc[0].to_dict()
+    s3, _ = run_step(3, FIVE_STEP_TITLES[2], "fintech_features", {}, lambda: {"feature_preview": feat_preview})
+    steps.append(s3)
+
+    # Model tool selection: default heuristic; if you later want LLM selector here, it can be added safely.
+    chosen_tool = "logreg_synth" if inp.get("use_ml_model", True) else "heuristic"
+    if chosen_tool not in FINTECH_TOOL_REGISTRY:
+        chosen_tool = "heuristic"
+
+    def _score():
+        fn = FINTECH_TOOL_REGISTRY[chosen_tool]
+        if chosen_tool == "heuristic":
+            return fn(df_feat)  # type: ignore
+        return fn(df_feat, seed=DEFAULT_SYNTHETIC_SEED)  # type: ignore
+
+    s4, score = run_step(4, FIVE_STEP_TITLES[3], f"python_dispatch::{chosen_tool}", {}, _score)
+    steps.append(s4)
+    score = score if isinstance(score, dict) else fintech_tool_heuristic(df_feat)
+
+    requested_amount = float(inp["requested_amount"])
+    s5, rec = run_step(5, FIVE_STEP_TITLES[4], "fintech_recommend", {"requested_amount": requested_amount}, lambda: fintech_recommend(score, requested_amount))
+    steps.append(s5)
+    rec = rec if isinstance(rec, dict) else {"decision": "Needs Human Review", "hitl_urgency_0_100": 100.0, "prediction_pd": float(score.get("pd_risk", 0.5))}
+
+    final = {
+        "decision": rec["decision"],
+        "pd_risk": float(score.get("pd_risk", 0.5)),
+        "confidence_0_100": float(score.get("confidence_0_100", 0.0)),
+        "hitl_urgency_0_100": float(rec.get("hitl_urgency_0_100", score.get("hitl_urgency_0_100", 100.0))),
+        "selected_tool": chosen_tool,
+        "auc_test_synth": float(score.get("auc_test_synth", -1.0)),
+    }
+
+    # build step bullets (Python, always non-empty)
+    step_bullets = {
+        1: [
+            "Captured account context and key request parameters.",
+            f"Requested amount = {requested_amount:.0f}, employment = {inp['employment_status']}, fraud_flag = {inp['fraud_flag']}.",
+        ],
+        2: [
+            "Checked and filled missing values using simple deterministic rules.",
+            f"Missing values: before {prep.get('missing_before', {})} → after {prep.get('missing_after', {})}.",
+        ],
+        3: [
+            "Engineered core risk features (DTI, credit score gap, missed payments, tenure, liquidity, collateral, fraud).",
+            "These features act as inputs to the scoring model.",
+        ],
+        4: [
+            f"Ran scoring tool: {chosen_tool}.",
+            f"Produced PD={final['pd_risk']:.3f} and confidence={final['confidence_0_100']:.1f}/100.",
+        ],
+        5: [
+            "Converted score to an operational decision using HITL urgency and confidence.",
+            f"Decision={final['decision']} with HITL_urgency={final['hitl_urgency_0_100']:.1f}/100.",
+        ],
+    }
+
+    evidence_md = (
+        f"- Tool used: `{chosen_tool}`\n"
+        f"- Key engineered features (preview):\n\n```json\n{json.dumps(feat_preview, indent=2)}\n```\n"
+    )
+    if final.get("auc_test_synth", -1.0) >= 0:
+        evidence_md += f"- Synthetic AUC (internal): `{final['auc_test_synth']:.3f}`\n"
+
+    prediction_bullet = f"Predicted delinquency probability (PD) = {final['pd_risk']:.3f}"
+    decision_bullet = f"{final['decision']} (confidence={final['confidence_0_100']:.1f}/100, HITL_urgency={final['hitl_urgency_0_100']:.1f}/100)"
+
+    explanation_md = build_5step_explanation_md("FinTech Credit Risk", step_bullets, evidence_md, prediction_bullet, decision_bullet)
+
+    report = (
+        "## Result\n"
+        f"- Decision: **{final['decision']}**\n"
+        f"- Delinquency probability (PD): **{final['pd_risk']:.3f}**\n"
+        f"- Confidence score: **{final['confidence_0_100']:.1f}/100**\n"
+        f"- HITL urgency: **{final['hitl_urgency_0_100']:.1f}/100**\n"
+        f"- Tool used: `{final['selected_tool']}`\n\n"
+        f"{explanation_md}"
+    )
+
+    payload = {
+        **meta,
+        "about": about,
+        "inputs": inp,
+        "steps": [asdict(x) for x in steps],
+        "outputs": {"final": final, "preprocess": prep, "feature_preview": feat_preview},
+    }
+    LOGGER.append(payload)
+    return report, payload
+
+def run_te_workflow(thread_id: str, about: str, inp: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    meta = run_metadata("te_pricing", thread_id)
+    steps: List[StepTrace] = []
+
+    s1, _ = run_step(1, FIVE_STEP_TITLES[0], "context_capture", {"about_preview": about[:200]}, lambda: {"about_len": len(about)})
+    steps.append(s1)
+
+    s2, checks = run_step(2, FIVE_STEP_TITLES[1], "te_input_checks", {}, lambda: {
+        "checks": {
+            "discount_range": 0.0 < float(inp["discount"]) < 0.9,
+            "cogs_gt_0": float(inp["cogs"]) > 0,
+            "landed_gt_0": float(inp["landed"]) > 0,
+        }
+    })
+    steps.append(s2)
+
+    # Step 3: derive
+    floor = max(7.0 * float(inp["cogs"]), float(inp["presale_mult"]) * float(inp["cogs"]))
+    s3, derived = run_step(3, FIVE_STEP_TITLES[2], "te_derive", {}, lambda: {
+        "presale_floor": floor,
+        "implied_retail_floor": floor / max(1e-6, (1.0 - float(inp["discount"]))),
+        "channel": str(inp.get("channel", "")),
+        "segment": str(inp.get("target_segment", "")),
+        "expected_units": int(inp.get("expected_presale_units", 0)),
+        "demand_index": float(inp.get("demand_index", 60.0)),
+        "price_sensitivity": float(inp.get("price_sensitivity", 60.0)),
+        "price_step": float(inp.get("price_step", 10.0)),
+    })
+    steps.append(s3)
+
+    # Step 4: Python pricing heuristic always runs (so not stuck at 42/52)
+    s4, base_price = run_step(4, FIVE_STEP_TITLES[3], "pricing_heuristic", {}, lambda: te_pricing_heuristic(inp))
+    steps.append(s4)
+    base_price = base_price if isinstance(base_price, dict) else te_pricing_heuristic(inp)
+
+    # Optional LLM adjustment (if key exists)
+    client = _client_or_none()
+    adj = None
+    if client is not None:
+        s4b, adj = run_step(4, "LLM Adjustment (optional)", "llm_adjustment", {}, lambda: llm_te_adjustment(client, about, inp, base_price))
+        # keep as step 4.5 in trace by using step_no=4 but different title; still 5-step in main trace? We keep it in steps list.
+        steps.append(s4b)
+    else:
+        adj = {"confidence_0_100": 0.0, "rationale_bullets": ["LLM adjustment skipped (no API key)."], "competitor_range": {"low": 0.0, "high": 0.0}}
+
+    # Apply adjustment deltas safely
+    presale = float(base_price["presale_price"]) + float(adj.get("adj_presale_delta", 0.0))
+    retail = float(base_price["retail_price"]) + float(adj.get("adj_retail_delta", 0.0))
+
+    # Re-enforce constraints
+    presale = max(presale, floor)
+    retail_floor = presale / max(1e-6, (1.0 - float(inp["discount"])))
+    retail = max(retail, retail_floor)
+
+    presale = as_99(presale)
+    retail = as_99(retail)
+    if retail <= presale:
+        retail = as_99(retail_floor)
+
+    final = {
+        "presale_price": presale,
+        "retail_price": retail,
+        "unit_margin_presale": float(presale - float(inp["landed"])),
+        "unit_margin_retail": float(retail - float(inp["landed"])),
+        "checks": {
+            "presale_ge_7xcogs": presale >= 7.0 * float(inp["cogs"]),
+            "presale_ge_floor": presale >= floor,
+            "retail_gt_presale": retail > presale,
+            "presale_gt_landed": presale > float(inp["landed"]),
+            "retail_gt_landed": retail > float(inp["landed"]),
+        },
+        "llm_confidence_0_100": float(adj.get("confidence_0_100", 0.0)),
+        "competitor_range": adj.get("competitor_range", {"low": 0.0, "high": 0.0}),
+        "tool_used": "pricing_heuristic (+optional_llm_adjustment)",
+    }
+
+    s5, _ = run_step(5, FIVE_STEP_TITLES[4], "te_finalize", {}, lambda: final)
+    steps.append(s5)
+
+    # Explanation bullets (Python, always non-empty)
+    step_bullets = {
+        1: [
+            "Captured product/channel/segment context and pricing constraints.",
+            f"Channel={inp.get('channel')}, segment={inp.get('target_segment')}, expected_units={int(inp.get('expected_presale_units', 0))}.",
+        ],
+        2: [
+            "Validated inputs and constraints (COGS, landed, discount range).",
+            f"Key constraint: presale floor = max(7×COGS, multiplier×COGS) = {floor:.2f}.",
+        ],
+        3: [
+            "Derived operational floor prices and retail floor implied by discount.",
+            f"Implied retail floor ≈ {floor / max(1e-6, (1.0 - float(inp['discount']))):.2f}.",
+        ],
+        4: [
+            "Computed a value-based retail anchor using segment + channel + volume signals (Python heuristic).",
+            f"Optional LLM adjustment used only if API key exists (LLM_conf={final['llm_confidence_0_100']:.0f}/100).",
+        ],
+        5: [
+            "Output final recommended presale/retail prices and margins, plus constraint checks.",
+            f"Presale={final['presale_price']:.2f}, Retail={final['retail_price']:.2f}.",
+        ],
+    }
+
+    evidence_md = (
+        f"- Tool used: `{final['tool_used']}`\n"
+        f"- Base anchors: `{base_price.get('anchors', {})}`\n"
+        f"- Competitor range (optional, no browsing): `{final['competitor_range']}`\n"
+        f"- Checks: `{final['checks']}`\n"
+    )
+    if adj and adj.get("rationale_bullets"):
+        evidence_md += "- LLM rationale (optional):\n"
+        for b in adj["rationale_bullets"][:7]:
+            evidence_md += f"  - {b}\n"
+
+    prediction_bullet = f"Recommended presale={final['presale_price']:.2f}, retail={final['retail_price']:.2f}"
+    decision_bullet = "Decision Draft (pricing recommendation ready). Human review recommended if brand/legal constraints are strict."
+
+    explanation_md = build_5step_explanation_md("TE Pricing", step_bullets, evidence_md, prediction_bullet, decision_bullet)
+
+    report = (
+        "## Result\n"
+        f"- Presale price: **{final['presale_price']:.2f}**\n"
+        f"- Retail price: **{final['retail_price']:.2f}**\n"
+        f"- Margin (presale/retail): **{final['unit_margin_presale']:.2f} / {final['unit_margin_retail']:.2f}**\n"
+        f"- Checks: `{final['checks']}`\n"
+        f"- Tool used: `{final['tool_used']}`\n\n"
+        f"{explanation_md}"
+    )
+
+    payload = {
+        **meta,
+        "about": about,
+        "inputs": inp,
+        "steps": [asdict(x) for x in steps],
+        "outputs": {"final": final, "derived": derived, "base_price": base_price, "llm_adjustment": adj},
+    }
+    LOGGER.append(payload)
+    return report, payload
+
+
+# =========================
+# Gradio UI
+# =========================
+def build_gradio_app():
+    import gradio as gr
+
+    STATE: Dict[str, Any] = {"last_payload": None}
+    emp_choices = ["Employed", "Self-employed", "Student", "Unemployed", "Retired", "Contract", "Other"]
+
+    def safe_call(fn):
+        try:
+            return fn()
+        except Exception:
+            tb = traceback.format_exc()
+            print(tb)
+            return "ERROR:\n\n```text\n" + tb + "\n```", ""
+
+    def ui_fintech(
+        about_account,
+        income, debt, credit_score,
+        employment_status,
+        missed_12m, months_on_book, credit_lines,
+        requested_amount,
+        savings, collateral_value,
+        fraud_flag, existing_customer,
+        use_ml_model,
+        thread_id
+    ):
+        def _do():
+            inp = {
+                "income": float(income),
+                "debt": float(debt),
+                "credit_score": int(credit_score),
+                "employment_status": str(employment_status),
+                "missed_payments_12m": int(missed_12m),
+                "months_on_book": int(months_on_book),
+                "credit_lines": int(credit_lines),
+                "requested_amount": float(requested_amount),
+                "savings": float(savings),
+                "collateral_value": float(collateral_value),
+                "fraud_flag": int(fraud_flag),
+                "existing_customer": int(existing_customer),
+                "use_ml_model": bool(use_ml_model),
+            }
+            report, payload = run_fintech_workflow(str(thread_id), str(about_account or ""), inp)
+            STATE["last_payload"] = payload
+            return report, payload["run_id"]
+        return safe_call(_do)
+
+    def ui_te(about_product, cogs, landed, presale_mult, discount, demand_index, price_sensitivity, price_step, channel, target_segment, expected_presale_units, thread_id):
+        def _do():
+            inp = {
+                "cogs": float(cogs),
+                "landed": float(landed),
+                "presale_mult": float(presale_mult),
+                "discount": float(discount),
+                "demand_index": float(demand_index),
+            "price_sensitivity": float(price_sensitivity),
+            "price_step": float(price_step),
+                "channel": str(channel),
+                "target_segment": str(target_segment),
+                "expected_presale_units": int(expected_presale_units),
+            }
+            about_text = str(about_product or "").strip()
+            if not about_text:
+                about_text = f"channel={inp['channel']}; segment={inp['target_segment']}; expected_presale_units={inp['expected_presale_units']}"
+            report, payload = run_te_workflow(str(thread_id), about_text, inp)
+            STATE["last_payload"] = payload
+            return report, payload["run_id"]
+        return safe_call(_do)
+
+    def ui_current_trace():
+        p = STATE.get("last_payload")
+        if not p:
+            return "No run yet."
+        return json.dumps(p, indent=2)
+
+    def ui_logs(n):
+        return json.dumps(LOGGER.tail(int(n)), indent=2)
+
+    with gr.Blocks(title=APP_TITLE) as demo:
+        gr.Markdown("## Demo C")
+
+        with gr.Row():
+            thread_id = gr.Textbox(value="demo_thread", label="thread_id")
+
+        with gr.Tabs():
+            with gr.Tab("FinTech"):
+                with gr.Row():
+                    with gr.Column(scale=5, min_width=480):
+                        gr.Markdown("### Inputs")
+                        about_account = gr.Textbox(
+                            label="About this account (customer context)",
+                            lines=6,
+                            placeholder="Type customer/account details: repayment history, special situations, collateral notes, verification notes, etc."
+                        )
+
+                        employment_status = gr.Dropdown(choices=emp_choices, value="Employed", label="Employment status")
+
+                        with gr.Row():
+                            income = gr.Number(value=75000, label="Income (annual)")
+                            debt = gr.Number(value=30000, label="Debt (total)")
+                        with gr.Row():
+                            credit_score = gr.Number(value=680, label="Credit score (300-850)")
+                            requested_amount = gr.Number(value=250000, label="Requested amount")
+                        with gr.Row():
+                            missed_12m = gr.Number(value=1, label="Missed payments (12m)")
+                            months_on_book = gr.Number(value=18, label="Months on book")
+                        credit_lines = gr.Number(value=4, label="Credit lines")
+
+                        with gr.Row():
+                            savings = gr.Number(value=8000, label="Savings / liquid assets")
+                            collateral_value = gr.Number(value=0, label="Collateral value")
+
+                        with gr.Row():
+                            fraud_flag = gr.Dropdown(choices=[0, 1], value=0, label="Fraud flag (0/1)")
+                            existing_customer = gr.Dropdown(choices=[0, 1], value=1, label="Existing customer (0/1)")
+
+                        use_ml_model = gr.Checkbox(value=True, label="Use synthetic data")
+
+                        btn = gr.Button("Run", variant="primary")
+
+                    with gr.Column(scale=7, min_width=640):
+                        gr.Markdown("### Output")
+                        out = gr.Markdown(value="_(Run to see result.)_")
+                        run_id_out = gr.Textbox(label="run_id")
+
+                btn.click(
+                    fn=ui_fintech,
+                    inputs=[
+                        about_account,
+                        income, debt, credit_score,
+                        employment_status,
+                        missed_12m, months_on_book, credit_lines,
+                        requested_amount,
+                        savings, collateral_value,
+                        fraud_flag, existing_customer,
+                        use_ml_model,
+                        thread_id
+                    ],
+                    outputs=[out, run_id_out],
+                )
+
+            with gr.Tab("TE"):
+                with gr.Row():
+                    with gr.Column(scale=5, min_width=480):
+                        gr.Markdown("### Inputs")
+                        about_product = gr.Textbox(
+                            label="About this product/account (context)",
+                            lines=6,
+                            placeholder="Type product + customer context: segment, channel, positioning, constraints, demand signals."
+                        )
+
+                        with gr.Row():
+                            cogs = gr.Number(value=6, label="COGS per unit")
+                            landed = gr.Number(value=10, label="Landed cost per unit")
+                        with gr.Row():
+                            presale_mult = gr.Number(value=7, label="Presale floor multiplier")
+                            discount = gr.Number(value=0.20, label="Discount (0-0.9)")
+                        with gr.Row():
+                            demand_index = gr.Slider(0, 100, value=60, step=1, label="Demand level (0-100)")
+                            price_sensitivity = gr.Slider(0, 100, value=60, step=1, label="Price sensitivity (0-100)")
+                        price_step = gr.Dropdown(choices=[10, 20, 50], value=10, label="Price step ($)")
+                        channel = gr.Dropdown(choices=["DTC (Direct-to-Consumer)", "Amazon", "Retail", "Wholesale"], value="DTC", label="Channel")
+                        target_segment = gr.Dropdown(choices=["Budget", "Mid-market", "Premium"], value="Mid-market", label="Target segment")
+                        expected_presale_units = gr.Number(value=1000, label="Expected presale units (rough)")
+
+                        btn2 = gr.Button("Run", variant="primary")
+
+                    with gr.Column(scale=7, min_width=640):
+                        gr.Markdown("### Output")
+                        out2 = gr.Markdown(value="_(Run to see result.)_")
+                        run_id_out2 = gr.Textbox(label="run_id")
+
+                btn2.click(
+                    fn=ui_te,
+                    inputs=[about_product, cogs, landed, presale_mult, discount, demand_index, price_sensitivity, price_step, channel, target_segment, expected_presale_units, thread_id],
+                    outputs=[out2, run_id_out2],
+                )
+
+            with gr.Tab("Trace"):
+                gr.Markdown("### Current run (full trace JSON)")
+                btn3 = gr.Button("Show current run")
+                cur = gr.Code(language="json")
+                btn3.click(fn=ui_current_trace, inputs=[], outputs=[cur])
+
+                gr.Markdown("### Log tail (JSONL)")
+                n = gr.Slider(10, 200, value=30, step=10, label="show last N runs")
+                btn4 = gr.Button("Refresh logs")
+                logs = gr.Code(language="json")
+                btn4.click(fn=ui_logs, inputs=[n], outputs=[logs])
+
+    return demo
+
+
+def main():
+    demo = build_gradio_app()
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")), debug=True)
+
+
+if __name__ == "__main__":
+    main()

demo_c.py

@@ -0,0 +1,1102 @@
+from __future__ import annotations
+
+"""
+FINAL DEMO (v10.2): Stable, runs locally + HF Spaces.
+
+Design goals (per your 5-step analyst workflow)
+- Output must always be non-empty and human-readable.
+- Trace tab must record: run_id / model_id / version_id / policy_id + 5 steps + tool_used per step.
+- NO LangGraph. NO LLM tool-calling.
+- FinTech:
+  - Python computes PD + confidence + HITL urgency (and optional model choice via LLM selector).
+  - Output includes explicit prediction + decision bullet.
+- TE Pricing:
+  - Primary: Python "pricing_heuristic" (value/segment/channel aware) so it won't stick to 42/52.
+  - Optional: LLM proposes a price range and adjustments (no browsing). If LLM fails, we still output a valid result.
+  - Hard constraints enforced in Python: presale >= max(7*COGS, mult*COGS), retail > presale.
+
+HF Spaces:
+- Rename to app.py
+- Set OPENAI_API_KEY in Space Secrets (optional for TE/FinTech explanation add-on, NOT required for base output)
+"""
+
+import json
+import math
+import os
+import sys
+import time
+import uuid
+import traceback
+from dataclasses import dataclass, asdict, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+# OpenAI is OPTIONAL (we never allow "no content" if API fails)
+try:
+    from openai import OpenAI
+except Exception:
+    OpenAI = None
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import roc_auc_score
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+
+
+print("\n========== FINAL_APP BOOT (v10.6) ==========")
+print("RUNNING_FILE =", __file__)
+print("CWD =", os.getcwd())
+print("PYTHON =", sys.executable)
+print("OPENAI_MODEL =", os.getenv("OPENAI_MODEL", "gpt-4o-mini"))
+print("OPENAI_API_KEY_SET =", "YES" if bool(os.getenv("OPENAI_API_KEY", "")) else "NO")
+print("===========================================\n")
+
+
+# =========================
+# Config
+# =========================
+APP_TITLE = "Demo C"
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+AGENT_ID = os.getenv("AGENT_ID", "nexdatawork_demo_agent")
+MODEL_ID = os.getenv("MODEL_ID", "python_5step_traceable")
+VERSION_ID = os.getenv("VERSION_ID", "10.6.0")
+
+POLICY_ID = os.getenv("POLICY_ID", "5step_traceable_policy")
+POLICY_VERSION = os.getenv("POLICY_VERSION", "10.6")
+
+DATA_DIR = Path(os.getenv("DATA_DIR", "./data"))
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+RUN_LOG_PATH = DATA_DIR / os.getenv("RUN_LOG_PATH", "run_logs.jsonl")
+
+DEFAULT_SYNTHETIC_SEED = 42
+HIGH_IMPACT_AMOUNT = float(os.getenv("HIGH_IMPACT_AMOUNT", "1000000"))
+
+
+# =========================
+# Helpers
+# =========================
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+def new_id(prefix: str) -> str:
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return f"{prefix}_{ts}_{uuid.uuid4().hex[:8]}"
+
+def clamp(x: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, x))
+
+def sigmoid(x: float) -> float:
+    if x >= 0:
+        z = math.exp(-x)
+        return 1.0 / (1.0 + z)
+    z = math.exp(x)
+    return z / (1.0 + z)
+
+def as_99(x: float) -> float:
+    v = round(float(x))
+    return float(f"{max(v, 1) - 0.01:.2f}")
+
+def run_metadata(task_type: str, thread_id: str) -> Dict[str, Any]:
+    return {
+        "run_id": new_id("run"),
+        "agent_id": AGENT_ID,
+        "model_id": MODEL_ID,
+        "version_id": VERSION_ID,
+        "policy_id": POLICY_ID,
+        "policy_version": POLICY_VERSION,
+        "llm_model": OPENAI_MODEL,
+        "task_type": task_type,
+        "thread_id": thread_id,
+        "timestamps": {"created_at": utc_now()},
+    }
+
+
+# =========================
+# JSONL Logger
+# =========================
+class JSONLLogger:
+    def __init__(self, path: Path):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def append(self, payload: Dict[str, Any]) -> None:
+        with self.path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+    def tail(self, n: int = 50) -> List[Dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        lines = self.path.read_text(encoding="utf-8").splitlines()
+        out: List[Dict[str, Any]] = []
+        for ln in lines[-n:]:
+            try:
+                out.append(json.loads(ln))
+            except Exception:
+                continue
+        return out
+
+LOGGER = JSONLLogger(RUN_LOG_PATH)
+
+
+# =========================
+# Trace structures
+# =========================
+@dataclass
+class StepTrace:
+    step_id: str
+    step_no: int
+    title: str
+    tool_used: str
+    started_at: str
+    ended_at: str
+    duration_ms: int
+    inputs: Dict[str, Any] = field(default_factory=dict)
+    outputs: Dict[str, Any] = field(default_factory=dict)
+    error: Optional[str] = None
+
+def run_step(step_no: int, title: str, tool_used: str, inputs: Dict[str, Any], fn) -> Tuple[StepTrace, Any]:
+    step_id = new_id("step")
+    started = utc_now()
+    t0 = time.time()
+    err = None
+    out = None
+    out_obj: Dict[str, Any] = {}
+    try:
+        out = fn()
+        if isinstance(out, dict):
+            out_obj = out
+        else:
+            out_obj = {"value": out}
+    except Exception:
+        err = traceback.format_exc()
+    ended = utc_now()
+    dur = int((time.time() - t0) * 1000)
+    return StepTrace(
+        step_id=step_id,
+        step_no=step_no,
+        title=title,
+        tool_used=tool_used,
+        started_at=started,
+        ended_at=ended,
+        duration_ms=dur,
+        inputs=inputs,
+        outputs=out_obj if err is None else {},
+        error=err,
+    ), out
+
+
+# =========================
+# Optional LLM helpers (never required)
+# =========================
+def _client_or_none():
+    if OpenAI is None:
+        return None
+    if not os.getenv("OPENAI_API_KEY", ""):
+        return None
+    try:
+        return OpenAI()
+    except Exception:
+        return None
+
+def llm_te_adjustment(client: Any, about: str, inputs: Dict[str, Any], base: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Optional: ask LLM for adjustment factor and competitor range.
+    Must not break if it fails.
+    """
+    prompt = {
+        "about": about,
+        "inputs": inputs,
+        "base": base,
+        "instruction": (
+            "No browsing. Return STRICT JSON: "
+            "{"
+            "\"adj_presale_delta\": number, "
+            "\"adj_retail_delta\": number, "
+            "\"competitor_range\": {\"low\": number, \"high\": number}, "
+            "\"confidence_0_100\": number, "
+            "\"rationale_bullets\": [..]"
+            "}. Keep bullets 4-7."
+        ),
+    }
+    try:
+        resp = client.chat.completions.create(
+            model=OPENAI_MODEL,
+            temperature=0.2,
+            messages=[
+                {"role": "system", "content": "Return STRICT JSON only. No markdown."},
+                {"role": "user", "content": json.dumps(prompt)},
+            ],
+        )
+        raw = (resp.choices[0].message.content or "").strip()
+        obj = json.loads(raw)
+        return {
+            "adj_presale_delta": float(obj.get("adj_presale_delta", 0.0)),
+            "adj_retail_delta": float(obj.get("adj_retail_delta", 0.0)),
+            "competitor_range": obj.get("competitor_range", {}) or {"low": 0.0, "high": 0.0},
+            "confidence_0_100": float(clamp(float(obj.get("confidence_0_100", 50.0)), 0.0, 100.0)),
+            "rationale_bullets": [str(x)[:200] for x in (obj.get("rationale_bullets", []) or [])][:10],
+            "raw": raw[:1400],
+        }
+    except Exception as e:
+        return {
+            "error": str(e)[:400],
+            "adj_presale_delta": 0.0,
+            "adj_retail_delta": 0.0,
+            "competitor_range": {"low": 0.0, "high": 0.0},
+            "confidence_0_100": 0.0,
+            "rationale_bullets": ["LLM adjustment unavailable (API missing or invalid JSON)."],
+        }
+
+
+# =========================
+# FinTech tools
+# =========================
+def fintech_build_row(inp: Dict[str, Any]) -> pd.DataFrame:
+    return pd.DataFrame([{
+        "Income": inp["income"],
+        "Debt": inp["debt"],
+        "Credit_Score": inp["credit_score"],
+        "Employment_Status": inp["employment_status"],
+        "Missed_Payments_12m": inp["missed_payments_12m"],
+        "Months_On_Book": inp["months_on_book"],
+        "Credit_Lines": inp["credit_lines"],
+        "Requested_Amount": inp["requested_amount"],
+        "Savings": inp["savings"],
+        "Collateral_Value": inp["collateral_value"],
+        "Fraud_Flag": inp["fraud_flag"],
+        "Existing_Customer": inp["existing_customer"],
+    }])
+
+def fintech_preprocess(df: pd.DataFrame) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    out = df.copy()
+    missing_before = out.isna().sum().astype(int).to_dict()
+    for col in out.columns:
+        if pd.api.types.is_numeric_dtype(out[col]):
+            if out[col].isna().any():
+                med = pd.to_numeric(out[col], errors="coerce").median()
+                out[col] = pd.to_numeric(out[col], errors="coerce").fillna(med)
+        else:
+            if out[col].isna().any():
+                out[col] = out[col].fillna("Unknown")
+    missing_after = out.isna().sum().astype(int).to_dict()
+    return out, {"missing_before": missing_before, "missing_after": missing_after}
+
+def fintech_features(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    income = out["Income"].clip(lower=1.0)
+    debt = out["Debt"].clip(lower=0.0)
+    savings = out["Savings"].clip(lower=0.0)
+    collateral = out["Collateral_Value"].clip(lower=0.0)
+    amount = out["Requested_Amount"].clip(lower=1.0)
+
+    out["DTI"] = (debt / income).clip(lower=0, upper=5)
+    out["Savings_to_Income"] = (savings / income).clip(lower=0, upper=5)
+    out["Collateral_to_Amount"] = (collateral / amount).clip(lower=0, upper=10)
+
+    out["Score_Gap"] = ((850 - out["Credit_Score"]) / 550).clip(lower=0, upper=1)
+    out["Missed_Norm"] = (out["Missed_Payments_12m"].clip(lower=0, upper=12) / 12.0)
+    out["Tenure_Norm"] = (out["Months_On_Book"].clip(lower=0, upper=120) / 120.0)
+    out["Lines_Norm"] = (out["Credit_Lines"].clip(lower=0, upper=20) / 20.0)
+
+    emp = out["Employment_Status"].astype(str).str.lower().str.strip()
+    emp_w = emp.map({
+        "employed": 0.00, "self-employed": 0.05, "student": 0.08,
+        "unemployed": 0.18, "retired": 0.04, "contract": 0.06, "other": 0.07
+    }).fillna(0.07)
+    out["Employment_Risk_Weight"] = emp_w
+
+    out["Fraud_Risk"] = out["Fraud_Flag"].astype(int).clip(0, 1)
+    out["Loyalty_Boost"] = out["Existing_Customer"].astype(int).clip(0, 1)
+    return out
+
+def fintech_tool_heuristic(df_feat: pd.DataFrame) -> Dict[str, Any]:
+    f = df_feat.iloc[0].to_dict()
+    x = (
+        -1.10
+        + 1.50 * f["DTI"]
+        + 1.20 * f["Score_Gap"]
+        + 0.95 * f["Missed_Norm"]
+        + 0.70 * f["Employment_Risk_Weight"]
+        - 0.35 * f["Tenure_Norm"]
+        - 0.25 * f["Lines_Norm"]
+        - 0.45 * f["Savings_to_Income"]
+        - 0.35 * f["Collateral_to_Amount"]
+        + 2.00 * f["Fraud_Risk"]
+        - 0.20 * f["Loyalty_Boost"]
+    )
+    pd_risk = sigmoid(float(x))
+    conf = float(clamp(abs(pd_risk - 0.5) * 200.0, 0.0, 100.0))
+    urg = float(clamp((100.0 - conf) * 0.75, 0.0, 100.0))
+    return {"tool": "heuristic", "pd_risk": pd_risk, "confidence_0_100": conf, "hitl_urgency_0_100": urg, "linear_x": float(x)}
+
+def _fintech_make_synth_training(seed: int = 42, n: int = 1500) -> pd.DataFrame:
+    rng = np.random.default_rng(seed)
+    income = rng.lognormal(mean=np.log(65000), sigma=0.55, size=n).clip(12000, 250000)
+    debt = rng.lognormal(mean=np.log(18000), sigma=0.75, size=n).clip(0, 200000)
+    score = rng.integers(300, 851, size=n)
+    missed = rng.integers(0, 7, size=n)
+    mob = rng.integers(0, 121, size=n)
+    lines = rng.integers(0, 21, size=n)
+    savings = rng.lognormal(mean=np.log(8000), sigma=0.9, size=n).clip(0, 200000)
+    collateral = rng.lognormal(mean=np.log(15000), sigma=0.9, size=n).clip(0, 300000)
+    fraud = rng.binomial(1, 0.03, size=n)
+    existing = rng.binomial(1, 0.55, size=n)
+    emp = rng.choice(["Employed","Self-employed","Student","Unemployed","Retired","Contract","Other"], size=n)
+    req_amount = rng.lognormal(mean=np.log(25000), sigma=0.8, size=n).clip(500, 250000)
+
+    df = pd.DataFrame({
+        "Income": income, "Debt": debt, "Credit_Score": score,
+        "Employment_Status": emp, "Missed_Payments_12m": missed,
+        "Months_On_Book": mob, "Credit_Lines": lines,
+        "Requested_Amount": req_amount,
+        "Savings": savings,
+        "Collateral_Value": collateral,
+        "Fraud_Flag": fraud,
+        "Existing_Customer": existing,
+    })
+    df_clean, _ = fintech_preprocess(df)
+    df_feat = fintech_features(df_clean)
+
+    x = (
+        -1.10
+        + 1.50 * df_feat["DTI"]
+        + 1.20 * df_feat["Score_Gap"]
+        + 0.95 * df_feat["Missed_Norm"]
+        + 0.70 * df_feat["Employment_Risk_Weight"]
+        - 0.35 * df_feat["Tenure_Norm"]
+        - 0.25 * df_feat["Lines_Norm"]
+        - 0.45 * df_feat["Savings_to_Income"]
+        - 0.35 * df_feat["Collateral_to_Amount"]
+        + 2.00 * df_feat["Fraud_Risk"]
+        - 0.20 * df_feat["Loyalty_Boost"]
+    )
+    p = 1 / (1 + np.exp(-x))
+    y = rng.binomial(1, p).astype(int)
+
+    df_feat = df_feat.copy()
+    df_feat["y"] = y
+    return df_feat
+
+def fintech_tool_logreg_synth(df_case_feat: pd.DataFrame, seed: int = 42) -> Dict[str, Any]:
+    train_df = _fintech_make_synth_training(seed=seed, n=1500)
+    cols = [
+        "DTI","Score_Gap","Missed_Norm","Tenure_Norm","Lines_Norm",
+        "Employment_Risk_Weight","Savings_to_Income","Collateral_to_Amount","Fraud_Risk","Loyalty_Boost"
+    ]
+    X = train_df[cols].astype(float)
+    y = train_df["y"].astype(int)
+
+    X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=seed, stratify=y)
+    model = LogisticRegression(max_iter=1000, solver="lbfgs")
+    model.fit(X_tr, y_tr)
+
+    auc = float(roc_auc_score(y_te, model.predict_proba(X_te)[:, 1]))
+    case_x = df_case_feat[cols].astype(float)
+
+    pd_risk = float(model.predict_proba(case_x)[:, 1][0])
+    conf = float(clamp(abs(pd_risk - 0.5) * 200.0, 0.0, 100.0))
+    urg = float(clamp((100.0 - conf) * 0.75, 0.0, 100.0))
+    return {"tool": "logreg_synth", "auc_test_synth": auc, "pd_risk": pd_risk, "confidence_0_100": conf, "hitl_urgency_0_100": urg}
+
+def fintech_tool_tree_synth(df_case_feat: pd.DataFrame, seed: int = 42) -> Dict[str, Any]:
+    train_df = _fintech_make_synth_training(seed=seed, n=1500)
+    cols = [
+        "DTI","Score_Gap","Missed_Norm","Tenure_Norm","Lines_Norm",
+        "Employment_Risk_Weight","Savings_to_Income","Collateral_to_Amount","Fraud_Risk","Loyalty_Boost"
+    ]
+    X = train_df[cols].astype(float)
+    y = train_df["y"].astype(int)
+
+    X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=seed, stratify=y)
+    model = DecisionTreeClassifier(max_depth=4, random_state=seed)
+    model.fit(X_tr, y_tr)
+
+    auc = float(roc_auc_score(y_te, model.predict_proba(X_te)[:, 1]))
+    case_x = df_case_feat[cols].astype(float)
+
+    pd_risk = float(model.predict_proba(case_x)[:, 1][0])
+    conf = float(clamp(abs(pd_risk - 0.5) * 200.0, 0.0, 100.0))
+    urg = float(clamp((100.0 - conf) * 0.75, 0.0, 100.0))
+    return {"tool": "tree_synth", "auc_test_synth": auc, "pd_risk": pd_risk, "confidence_0_100": conf, "hitl_urgency_0_100": urg}
+
+FINTECH_TOOL_REGISTRY = {
+    "heuristic": fintech_tool_heuristic,
+    "logreg_synth": fintech_tool_logreg_synth,
+    "tree_synth": fintech_tool_tree_synth,
+}
+
+def fintech_recommend(score: Dict[str, Any], requested_amount: float) -> Dict[str, Any]:
+    conf = float(score.get("confidence_0_100", 0.0))
+    urg = float(score.get("hitl_urgency_0_100", 100.0))
+    bump = 0.0
+    if HIGH_IMPACT_AMOUNT > 0 and requested_amount > 0:
+        ratio = requested_amount / HIGH_IMPACT_AMOUNT
+        bump = 20.0 * clamp(math.log10(ratio + 1.0) / math.log10(11.0), 0.0, 1.0)
+    urg2 = float(clamp(urg + bump, 0.0, 100.0))
+    decision = "Needs Human Review" if (urg2 >= 60.0 or conf <= 25.0) else "Decision Draft"
+    return {"decision": decision, "hitl_urgency_0_100": urg2, "prediction_pd": float(score.get("pd_risk", 0.5))}
+
+
+# =========================
+# TE pricing heuristic (PRIMARY)
+# =========================
+def te_pricing_heuristic(inp: Dict[str, Any]) -> Dict[str, Any]:
+    cogs = float(inp["cogs"])
+    landed = float(inp["landed"])
+    mult = float(inp["presale_mult"])
+    discount = float(inp["discount"])
+    channel = str(inp.get("channel", "DTC"))
+    segment = str(inp.get("target_segment", "Mid-market"))
+    units = int(inp.get("expected_presale_units", 0))
+
+    # User-friendly demand controls (0-100)
+    demand_index = float(inp.get("demand_index", 60.0))
+    price_sensitivity = float(inp.get("price_sensitivity", 60.0))
+    price_step = float(inp.get("price_step", 10.0))
+    demand_index = clamp(demand_index, 0.0, 100.0)
+    price_sensitivity = clamp(price_sensitivity, 0.0, 100.0)
+    price_step = max(1.0, float(price_step))
+
+    floor = max(7.0 * cogs, mult * cogs)
+
+    # segment anchor retail
+    # (pure heuristic so the AI demo doesn't get stuck at 42/52)
+    if segment.lower().startswith("budget"):
+        retail_anchor = 79.99
+    elif segment.lower().startswith("premium"):
+        retail_anchor = 149.99
+    else:
+        retail_anchor = 109.99
+
+    # channel adjustments
+    if channel.lower() == "amazon":
+        retail_anchor -= 10.0
+    elif channel.lower() == "retail":
+        retail_anchor += 10.0
+    elif channel.lower() == "wholesale":
+        retail_anchor -= 15.0
+
+    # volume signal: more units -> can accept slightly lower retail
+    if units >= 5000:
+        retail_anchor -= 8.0
+    elif units >= 2000:
+        retail_anchor -= 4.0
+    elif units > 0 and units < 300:
+        retail_anchor += 6.0
+
+    # Demand controls: higher demand_index supports higher willingness-to-pay; higher sensitivity pushes price down.
+    retail_anchor += (demand_index - 50.0) * 0.3  # up to about +/-15
+    retail_anchor -= (price_sensitivity - 50.0) * 0.2  # up to about +/-10
+
+    retail_floor_from_discount = floor / max(1e-6, (1.0 - discount))
+    retail = max(retail_anchor, retail_floor_from_discount)
+
+    presale = retail * (1.0 - discount)
+    presale = max(presale, floor)
+
+    presale = as_99(presale)
+    retail = as_99(retail)
+
+    # ensure retail>presale strictly
+    if retail <= presale:
+        retail = as_99(presale / max(1e-6, (1.0 - discount)))
+
+    checks = {
+        "presale_ge_7xcogs": presale >= 7.0 * cogs,
+        "presale_ge_floor": presale >= floor,
+        "retail_gt_presale": retail > presale,
+        "presale_gt_landed": presale > landed,
+        "retail_gt_landed": retail > landed,
+    }
+
+    return {
+        "tool": "pricing_heuristic",
+        "floor": floor,
+        "presale_price": presale,
+        "retail_price": retail,
+        "unit_margin_presale": float(presale - landed),
+        "unit_margin_retail": float(retail - landed),
+        "checks": checks,
+        "anchors": {"segment": segment, "channel": channel, "retail_anchor": retail_anchor, "units": units, "demand_index": demand_index, "price_sensitivity": price_sensitivity, "price_step": price_step},
+    }
+
+
+# =========================
+# 5-step explanation builder (Python, always non-empty)
+# =========================
+def build_5step_explanation_md(title: str, step_bullets: Dict[int, List[str]], evidence_md: str, prediction_bullet: str, decision_bullet: str) -> str:
+    md: List[str] = []
+    md.append("## Explanation")
+    # Use professional workflow section titles instead of "Step 1..5"
+    for i in range(1, 6):
+        section_title = FIVE_STEP_TITLES[i - 1]
+        md.append(f"### {section_title}")
+        blt = step_bullets.get(i, [])
+        if not blt:
+            blt = ["(no content)"]
+        for b in blt[:8]:
+            md.append(f"- {b}")
+    md.append("")
+    md.append("## Evidence")
+    md.append(evidence_md.strip() if evidence_md.strip() else "- (no evidence)")
+    md.append("")
+    md.append("## Prediction")
+    md.append(f"- {prediction_bullet}")
+    md.append("")
+    md.append("## Decision")
+    md.append(f"- {decision_bullet}")
+    return "\n".join(md).strip()
+
+
+
+# =========================
+# Simple visualizations (matplotlib)
+# =========================
+def plot_fintech_pd_bar(pd_risk: float):
+    """
+    Gauge-style horizontal bar (0-100%).
+    Robust for a single probability value.
+    """
+    import matplotlib.pyplot as plt
+
+    pd_risk = float(clamp(pd_risk, 0.0, 1.0))
+    pct = pd_risk * 100.0
+
+    fig = plt.figure(figsize=(6.0, 1.6))
+    ax = fig.add_subplot(111)
+
+    # Background track (100%)
+    ax.barh([0], [100], height=0.5, color="#e6e6e6")
+
+    # Foreground value
+    ax.barh([0], [pct], height=0.5, color="#1f77b4")
+
+    ax.set_xlim(0, 100)
+    ax.set_yticks([])
+    ax.set_xlabel("PD (%)")
+    ax.set_title(f"Delinquency probability (PD): {pct:.1f}%")
+
+    # Label at the end of the filled bar
+    ax.text(min(pct + 2, 98), 0, f"{pct:.1f}%", va="center", ha="left", fontsize=11)
+
+    ax.grid(axis="x", linestyle="--", alpha=0.3)
+    fig.tight_layout()
+    return fig
+
+def plot_te_price_stacked(presale: float, retail: float):
+    """
+    Overlay bars: Retail is the taller bar; Presale is the shorter bar on top (same x).
+    Also annotate values on bars. Keep it minimal and robust.
+    """
+    import matplotlib.pyplot as plt
+
+    presale = float(max(presale, 0.0))
+    retail = float(max(retail, presale))
+
+    fig = plt.figure(figsize=(6.0, 2.2))
+    ax = fig.add_subplot(111)
+
+    x = [0]
+    # Draw retail first (background), then presale (foreground)
+    bars_retail = ax.bar(x, [retail], width=0.6, color="#9f1bdd", label="Retail")
+    bars_presale = ax.bar(x, [presale], width=0.6, color="#4d74f3", label="Presale")
+
+    ax.set_xticks(x)
+    ax.set_xticklabels(["Price"])
+    ax.set_ylabel("$")
+    ax.set_title("Presale vs Retail")
+    ax.grid(axis="y", linestyle="--", alpha=0.3)
+    ymax = max(retail, presale)
+    ax.set_ylim(0, ymax * 1.25)
+
+    # Put legend outside the plot area on the right
+    ax.legend(loc="center left", bbox_to_anchor=(1.02, 0.5), frameon=False)
+
+    # Annotate values
+    def annotate(bar, value: float):
+        rect = bar[0]
+        ax.text(
+            rect.get_x() + rect.get_width() / 2.0,
+            rect.get_height() + max(1.0, 0.02 * retail),
+            f"${value:.2f}",
+            ha="center",
+            va="bottom",
+            fontsize=10,
+        )
+
+    annotate(bars_retail, retail)
+    annotate(bars_presale, presale)
+
+    fig.tight_layout()
+    return fig
+
+# =========================
+# Workflows
+# =========================
+FIVE_STEP_TITLES = [
+    "Interpreting Context & Metrics (Questions + EDA)",
+    "Pre-Processing Data (Cleaning + Missing Values)",
+    "Processing Data (Transform + Feature Build)",
+    "Analyzing Data (Modeling + Scoring)",
+    "Trend Analysis & Predictions (Decision + Share)",
+]
+def run_fintech_workflow(thread_id: str, about: str, inp: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    meta = run_metadata("fintech", thread_id)
+    steps: List[StepTrace] = []
+
+    s1, _ = run_step(1, FIVE_STEP_TITLES[0], "context_capture", {"about_preview": about[:200]}, lambda: {"about_len": len(about)})
+    steps.append(s1)
+
+    df_raw = fintech_build_row(inp)
+    df_clean, prep = fintech_preprocess(df_raw)
+    s2, _ = run_step(2, FIVE_STEP_TITLES[1], "fintech_preprocess", {}, lambda: prep)
+    steps.append(s2)
+
+    df_feat = fintech_features(df_clean)
+    feat_preview = df_feat[[
+        "DTI","Score_Gap","Missed_Norm","Tenure_Norm","Lines_Norm",
+        "Savings_to_Income","Collateral_to_Amount","Fraud_Risk","Loyalty_Boost"
+    ]].iloc[0].to_dict()
+    s3, _ = run_step(3, FIVE_STEP_TITLES[2], "fintech_features", {}, lambda: {"feature_preview": feat_preview})
+    steps.append(s3)
+
+    # Model tool selection: default heuristic; if you later want LLM selector here, it can be added safely.
+    chosen_tool = "logreg_synth" if inp.get("use_ml_model", True) else "heuristic"
+    if chosen_tool not in FINTECH_TOOL_REGISTRY:
+        chosen_tool = "heuristic"
+
+    def _score():
+        fn = FINTECH_TOOL_REGISTRY[chosen_tool]
+        if chosen_tool == "heuristic":
+            return fn(df_feat)  # type: ignore
+        return fn(df_feat, seed=DEFAULT_SYNTHETIC_SEED)  # type: ignore
+
+    s4, score = run_step(4, FIVE_STEP_TITLES[3], f"python_dispatch::{chosen_tool}", {}, _score)
+    steps.append(s4)
+    score = score if isinstance(score, dict) else fintech_tool_heuristic(df_feat)
+
+    requested_amount = float(inp["requested_amount"])
+    s5, rec = run_step(5, FIVE_STEP_TITLES[4], "fintech_recommend + viz_pd_bar", {"requested_amount": requested_amount}, lambda: fintech_recommend(score, requested_amount))
+    steps.append(s5)
+    rec = rec if isinstance(rec, dict) else {"decision": "Needs Human Review", "hitl_urgency_0_100": 100.0, "prediction_pd": float(score.get("pd_risk", 0.5))}
+
+    final = {
+        "decision": rec["decision"],
+        "pd_risk": float(score.get("pd_risk", 0.5)),
+        "confidence_0_100": float(score.get("confidence_0_100", 0.0)),
+        "hitl_urgency_0_100": float(rec.get("hitl_urgency_0_100", score.get("hitl_urgency_0_100", 100.0))),
+        "selected_tool": chosen_tool,
+        "auc_test_synth": float(score.get("auc_test_synth", -1.0)),
+    }
+
+    # build step bullets (Python, always non-empty)
+    step_bullets = {
+        1: [
+            "Captured account context and key request parameters.",
+            f"Requested amount = {requested_amount:.0f}, employment = {inp['employment_status']}, fraud_flag = {inp['fraud_flag']}.",
+        ],
+        2: [
+            "Checked and filled missing values using simple deterministic rules.",
+            f"Missing values: before {prep.get('missing_before', {})} → after {prep.get('missing_after', {})}.",
+        ],
+        3: [
+            "Engineered core risk features (DTI, credit score gap, missed payments, tenure, liquidity, collateral, fraud).",
+            "These features act as inputs to the scoring model.",
+        ],
+        4: [
+            f"Ran scoring tool: {chosen_tool}.",
+            f"Produced PD={final['pd_risk']*100:.1f}% and confidence={final['confidence_0_100']:.1f}/100.",
+        ],
+        5: [
+            "Converted score to an operational decision using HITL urgency and confidence.",
+            f"Decision={final['decision']} with HITL_urgency={final['hitl_urgency_0_100']:.1f}/100.",
+        ],
+    }
+
+    evidence_md = (
+        f"- Tool used: `{chosen_tool}`\n"
+        f"- Key engineered features (preview):\n\n```json\n{json.dumps(feat_preview, indent=2)}\n```\n"
+    )
+    if final.get("auc_test_synth", -1.0) >= 0:
+        evidence_md += f"- Synthetic AUC (internal): `{final['auc_test_synth']:.3f}`\n"
+
+    prediction_bullet = f"Predicted delinquency probability (PD) = {final['pd_risk']*100:.1f}%"
+    decision_bullet = f"{final['decision']} (confidence={final['confidence_0_100']:.1f}/100, HITL_urgency={final['hitl_urgency_0_100']:.1f}/100)"
+
+    explanation_md = build_5step_explanation_md("FinTech Credit Risk", step_bullets, evidence_md, prediction_bullet, decision_bullet)
+
+    report = (
+        "## Result\n"
+        f"- Decision: **{final['decision']}**\n"
+        f"- Delinquency probability (PD): **{final['pd_risk']*100:.1f}%**\n"
+        f"- Confidence score: **{final['confidence_0_100']:.1f}/100**\n"
+        f"- HITL urgency: **{final['hitl_urgency_0_100']:.1f}/100**\n"
+        f"- Tool used: `{final['selected_tool']}`\n\n"
+        f"{explanation_md}"
+    )
+
+    payload = {
+        **meta,
+        "about": about,
+        "inputs": inp,
+        "steps": [asdict(x) for x in steps],
+        "outputs": {"final": final, "preprocess": prep, "feature_preview": feat_preview},
+    }
+    LOGGER.append(payload)
+    return report, payload
+
+def run_te_workflow(thread_id: str, about: str, inp: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    meta = run_metadata("te_pricing", thread_id)
+    steps: List[StepTrace] = []
+
+    s1, _ = run_step(1, FIVE_STEP_TITLES[0], "context_capture", {"about_preview": about[:200]}, lambda: {"about_len": len(about)})
+    steps.append(s1)
+
+    s2, checks = run_step(2, FIVE_STEP_TITLES[1], "te_input_checks", {}, lambda: {
+        "checks": {
+            "discount_range": 0.0 < float(inp["discount"]) < 0.9,
+            "cogs_gt_0": float(inp["cogs"]) > 0,
+            "landed_gt_0": float(inp["landed"]) > 0,
+        }
+    })
+    steps.append(s2)
+
+    # Step 3: derive
+    floor = max(7.0 * float(inp["cogs"]), float(inp["presale_mult"]) * float(inp["cogs"]))
+    s3, derived = run_step(3, FIVE_STEP_TITLES[2], "te_derive", {}, lambda: {
+        "presale_floor": floor,
+        "implied_retail_floor": floor / max(1e-6, (1.0 - float(inp["discount"]))),
+        "channel": str(inp.get("channel", "")),
+        "segment": str(inp.get("target_segment", "")),
+        "expected_units": int(inp.get("expected_presale_units", 0)),
+        "demand_index": float(inp.get("demand_index", 60.0)),
+        "price_sensitivity": float(inp.get("price_sensitivity", 60.0)),
+        "price_step": float(inp.get("price_step", 10.0)),
+    })
+    steps.append(s3)
+
+    # Step 4: Python pricing heuristic always runs (so not stuck at 42/52)
+    s4, base_price = run_step(4, FIVE_STEP_TITLES[3], "pricing_heuristic", {}, lambda: te_pricing_heuristic(inp))
+    steps.append(s4)
+    base_price = base_price if isinstance(base_price, dict) else te_pricing_heuristic(inp)
+
+    # Optional LLM adjustment (if key exists)
+    client = _client_or_none()
+    adj = None
+    if client is not None:
+        s4b, adj = run_step(4, "LLM Adjustment (optional)", "llm_adjustment", {}, lambda: llm_te_adjustment(client, about, inp, base_price))
+        # keep as step 4.5 in trace by using step_no=4 but different title; still 5-step in main trace? We keep it in steps list.
+        steps.append(s4b)
+    else:
+        adj = {"confidence_0_100": 0.0, "rationale_bullets": ["LLM adjustment skipped (no API key)."], "competitor_range": {"low": 0.0, "high": 0.0}}
+
+    # Apply adjustment deltas safely
+    presale = float(base_price["presale_price"]) + float(adj.get("adj_presale_delta", 0.0))
+    retail = float(base_price["retail_price"]) + float(adj.get("adj_retail_delta", 0.0))
+
+    # Re-enforce constraints
+    presale = max(presale, floor)
+    retail_floor = presale / max(1e-6, (1.0 - float(inp["discount"])))
+    retail = max(retail, retail_floor)
+
+    presale = as_99(presale)
+    retail = as_99(retail)
+    if retail <= presale:
+        retail = as_99(retail_floor)
+
+    final = {
+        "presale_price": presale,
+        "retail_price": retail,
+        "unit_margin_presale": float(presale - float(inp["landed"])),
+        "unit_margin_retail": float(retail - float(inp["landed"])),
+        "checks": {
+            "presale_ge_7xcogs": presale >= 7.0 * float(inp["cogs"]),
+            "presale_ge_floor": presale >= floor,
+            "retail_gt_presale": retail > presale,
+            "presale_gt_landed": presale > float(inp["landed"]),
+            "retail_gt_landed": retail > float(inp["landed"]),
+        },
+        "llm_confidence_0_100": float(adj.get("confidence_0_100", 0.0)),
+        "competitor_range": adj.get("competitor_range", {"low": 0.0, "high": 0.0}),
+        "tool_used": "pricing_heuristic (+optional_llm_adjustment)",
+    }
+
+    s5, _ = run_step(5, FIVE_STEP_TITLES[4], "te_finalize + viz_price_stacked", {}, lambda: final)
+    steps.append(s5)
+
+    # Explanation bullets (Python, always non-empty)
+    step_bullets = {
+        1: [
+            "Captured product/channel/segment context and pricing constraints.",
+            f"Channel={inp.get('channel')}, segment={inp.get('target_segment')}, expected_units={int(inp.get('expected_presale_units', 0))}.",
+        ],
+        2: [
+            "Validated inputs and constraints (COGS, landed, discount range).",
+            f"Key constraint: presale floor = max(7×COGS, multiplier×COGS) = {floor:.2f}.",
+        ],
+        3: [
+            "Derived operational floor prices and retail floor implied by discount.",
+            f"Implied retail floor ≈ {floor / max(1e-6, (1.0 - float(inp['discount']))):.2f}.",
+        ],
+        4: [
+            "Computed a value-based retail anchor using segment + channel + volume signals (Python heuristic).",
+            f"Optional LLM adjustment used only if API key exists (LLM_conf={final['llm_confidence_0_100']:.0f}/100).",
+        ],
+        5: [
+            "Output final recommended presale/retail prices and margins, plus constraint checks.",
+            f"Presale={final['presale_price']:.2f}, Retail={final['retail_price']:.2f}.",
+        ],
+    }
+
+    evidence_md = (
+        f"- Tool used: `{final['tool_used']}`\n"
+        f"- Base anchors: `{base_price.get('anchors', {})}`\n"
+        f"- Competitor range (optional, no browsing): `{final['competitor_range']}`\n"
+        f"- Checks: `{final['checks']}`\n"
+    )
+    if adj and adj.get("rationale_bullets"):
+        evidence_md += "- LLM rationale (optional):\n"
+        for b in adj["rationale_bullets"][:7]:
+            evidence_md += f"  - {b}\n"
+
+    prediction_bullet = f"Recommended presale={final['presale_price']:.2f}, retail={final['retail_price']:.2f}"
+    decision_bullet = "Decision Draft (pricing recommendation ready). Human review recommended if brand/legal constraints are strict."
+
+    explanation_md = build_5step_explanation_md("TE Pricing", step_bullets, evidence_md, prediction_bullet, decision_bullet)
+
+    report = (
+        "## Result\n"
+        f"- Presale price: **{final['presale_price']:.2f}**\n"
+        f"- Retail price: **{final['retail_price']:.2f}**\n"
+        f"- Margin (presale/retail): **{final['unit_margin_presale']:.2f} / {final['unit_margin_retail']:.2f}**\n"
+        f"- Checks: `{final['checks']}`\n"
+        f"- Tool used: `{final['tool_used']}`\n\n"
+        f"{explanation_md}"
+    )
+
+    payload = {
+        **meta,
+        "about": about,
+        "inputs": inp,
+        "steps": [asdict(x) for x in steps],
+        "outputs": {"final": final, "derived": derived, "base_price": base_price, "llm_adjustment": adj},
+    }
+    LOGGER.append(payload)
+    return report, payload
+
+
+# =========================
+# Gradio UI
+# =========================
+def build_gradio_app():
+    import gradio as gr
+
+    STATE: Dict[str, Any] = {"last_payload": None}
+    emp_choices = ["Employed", "Self-employed", "Student", "Unemployed", "Retired", "Contract", "Other"]
+
+    def safe_call(fn):
+        try:
+            return fn()
+        except Exception:
+            tb = traceback.format_exc()
+            print(tb)
+            return "ERROR:\n\n```text\n" + tb + "\n```", None, ""
+
+    def ui_fintech(
+        about_account,
+        income, debt, credit_score,
+        employment_status,
+        missed_12m, months_on_book, credit_lines,
+        requested_amount,
+        savings, collateral_value,
+        fraud_flag, existing_customer,
+        use_ml_model,
+        thread_id
+    ):
+        def _do():
+            inp = {
+                "income": float(income),
+                "debt": float(debt),
+                "credit_score": int(credit_score),
+                "employment_status": str(employment_status),
+                "missed_payments_12m": int(missed_12m),
+                "months_on_book": int(months_on_book),
+                "credit_lines": int(credit_lines),
+                "requested_amount": float(requested_amount),
+                "savings": float(savings),
+                "collateral_value": float(collateral_value),
+                "fraud_flag": int(fraud_flag),
+                "existing_customer": int(existing_customer),
+                "use_ml_model": bool(use_ml_model),
+            }
+            report, payload = run_fintech_workflow(str(thread_id), str(about_account or ""), inp)
+            STATE["last_payload"] = payload
+            pd_val = float((payload.get("outputs") or {}).get("final", {}).get("pd_risk", 0.0))
+            fig = plot_fintech_pd_bar(pd_val)
+            return report, fig, payload["run_id"]
+        return safe_call(_do)
+
+    def ui_te(about_product, cogs, landed, presale_mult, discount, demand_index, price_sensitivity, price_step, channel, target_segment, expected_presale_units, thread_id):
+        def _do():
+            inp = {
+                "cogs": float(cogs),
+                "landed": float(landed),
+                "presale_mult": float(presale_mult),
+                "discount": float(discount),
+                "demand_index": float(demand_index),
+                "price_sensitivity": float(price_sensitivity),
+                "price_step": float(price_step),
+                "channel": str(channel),
+                "target_segment": str(target_segment),
+                "expected_presale_units": int(expected_presale_units),
+            }
+            about_text = str(about_product or "").strip()
+            if not about_text:
+                about_text = f"channel={inp['channel']}; segment={inp['target_segment']}; expected_presale_units={inp['expected_presale_units']}"
+            report, payload = run_te_workflow(str(thread_id), about_text, inp)
+            STATE["last_payload"] = payload
+            final = (payload.get("outputs") or {}).get("final", {}) or {}
+            presale = float(final.get("presale_price", 0.0))
+            retail = float(final.get("retail_price", 0.0))
+            fig = plot_te_price_stacked(presale, retail)
+            return report, fig, payload["run_id"]
+        return safe_call(_do)
+
+    def ui_current_trace():
+        p = STATE.get("last_payload")
+        if not p:
+            return "No run yet."
+        return json.dumps(p, indent=2)
+
+    def ui_logs(n):
+        return json.dumps(LOGGER.tail(int(n)), indent=2)
+
+    with gr.Blocks(title=APP_TITLE) as demo:
+        gr.Markdown("## Demo C")
+
+        with gr.Row():
+            thread_id = gr.Textbox(value="demo_thread", label="thread_id")
+
+        with gr.Tabs():
+            with gr.Tab("FinTech"):
+                with gr.Row():
+                    with gr.Column(scale=5, min_width=480):
+                        gr.Markdown("### Inputs")
+                        about_account = gr.Textbox(
+                            label="About this account (customer context)",
+                            lines=6,
+                            placeholder="Type customer/account details: repayment history, special situations, collateral notes, verification notes, etc."
+                        )
+
+                        employment_status = gr.Dropdown(choices=emp_choices, value="Employed", label="Employment status")
+
+                        with gr.Row():
+                            income = gr.Number(value=75000, label="Income (annual)")
+                            debt = gr.Number(value=30000, label="Debt (total)")
+                        with gr.Row():
+                            credit_score = gr.Number(value=680, label="Credit score (300-850)")
+                            requested_amount = gr.Number(value=250000, label="Requested amount")
+                        with gr.Row():
+                            missed_12m = gr.Number(value=1, label="Missed payments (12m)")
+                            months_on_book = gr.Number(value=18, label="Months on book")
+                        credit_lines = gr.Number(value=4, label="Credit lines")
+
+                        with gr.Row():
+                            savings = gr.Number(value=8000, label="Savings / liquid assets")
+                            collateral_value = gr.Number(value=0, label="Collateral value")
+
+                        with gr.Row():
+                            fraud_flag = gr.Dropdown(choices=[0, 1], value=0, label="Fraud flag (0/1)")
+                            existing_customer = gr.Dropdown(choices=[0, 1], value=1, label="Existing customer (0/1)")
+
+                        use_ml_model = gr.Checkbox(value=True, label="Use synthetic data")
+
+                        btn = gr.Button("Run", variant="primary")
+
+                    with gr.Column(scale=7, min_width=640):
+                        gr.Markdown("### Output")
+                        out = gr.Markdown(value="_(Run to see result.)_")
+                        fintech_plot = gr.Plot(label="PD visualization")
+                        run_id_out = gr.Textbox(label="run_id")
+
+                btn.click(
+                    fn=ui_fintech,
+                    inputs=[
+                        about_account,
+                        income, debt, credit_score,
+                        employment_status,
+                        missed_12m, months_on_book, credit_lines,
+                        requested_amount,
+                        savings, collateral_value,
+                        fraud_flag, existing_customer,
+                        use_ml_model,
+                        thread_id
+                    ],
+                    outputs=[out, fintech_plot, run_id_out],
+                )
+
+            with gr.Tab("TE"):
+                with gr.Row():
+                    with gr.Column(scale=5, min_width=480):
+                        gr.Markdown("### Inputs")
+                        about_product = gr.Textbox(
+                            label="About this product/account (context)",
+                            lines=6,
+                            placeholder="Type product + customer context: segment, channel, positioning, constraints, demand signals."
+                        )
+
+                        with gr.Row():
+                            cogs = gr.Number(value=6, label="COGS per unit")
+                            landed = gr.Number(value=10, label="Landed cost per unit")
+                        with gr.Row():
+                            presale_mult = gr.Number(value=7, label="Presale floor multiplier")
+                            discount = gr.Number(value=0.20, label="Discount (0-0.9)")
+                        with gr.Row():
+                            demand_index = gr.Slider(0, 100, value=60, step=1, label="Demand level (0-100)")
+                            price_sensitivity = gr.Slider(0, 100, value=60, step=1, label="Price sensitivity (0-100)")
+                        price_step = gr.Dropdown(choices=[10, 20, 50], value=10, label="Price step ($)")
+                        channel = gr.Dropdown(choices=["DTC (Direct-to-Consumer)", "Amazon", "Retail", "Wholesale"], value="DTC", label="Channel")
+                        target_segment = gr.Dropdown(choices=["Budget", "Mid-market", "Premium"], value="Mid-market", label="Target segment")
+                        expected_presale_units = gr.Number(value=1000, label="Expected presale units (rough)")
+
+                        btn2 = gr.Button("Run", variant="primary")
+
+                    with gr.Column(scale=7, min_width=640):
+                        gr.Markdown("### Output")
+                        out2 = gr.Markdown(value="_(Run to see result.)_")
+                        te_plot = gr.Plot(label="Price visualization")
+                        run_id_out2 = gr.Textbox(label="run_id")
+
+                btn2.click(
+                    fn=ui_te,
+                    inputs=[about_product, cogs, landed, presale_mult, discount, demand_index, price_sensitivity, price_step, channel, target_segment, expected_presale_units, thread_id],
+                    outputs=[out2, te_plot, run_id_out2],
+                )
+
+            with gr.Tab("Trace"):
+                gr.Markdown("### Current run (full trace JSON)")
+                btn3 = gr.Button("Show current run")
+                cur = gr.Code(language="json")
+                btn3.click(fn=ui_current_trace, inputs=[], outputs=[cur])
+
+                gr.Markdown("### Log tail (JSONL)")
+                n = gr.Slider(10, 200, value=30, step=10, label="show last N runs")
+                btn4 = gr.Button("Refresh logs")
+                logs = gr.Code(language="json")
+                btn4.click(fn=ui_logs, inputs=[n], outputs=[logs])
+
+    return demo
+
+
+def main():
+    demo = build_gradio_app()
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")), debug=True)
+
+
+if __name__ == "__main__":
+    main()

framework_demo_b.py

@@ -1,81 +1,64 @@
-"""
-LangGraph + LangChain Framework Demo (Stateful + Traceable) with OpenAI
-
-This version is closer to LangChain/LangGraph "agent + memory" patterns:
-- LangGraph ReAct agent (tool-calling) with short-term memory via checkpointer (thread_id)
-- Traceable run logs: run_id, model_id, version_id, policy_id, step traces, evidence
-- Two business workflows:
-  1) FinTech credit risk demo (single case) + HITL policy routing
-  2) TE consumer product pricing (presale + retail) + constraint checks + benchmark draft (LLM, no web)
-
-Gradio:
-- Tab 1: FinTech (form -> agent decides tools -> structured output + explanation)
-- Tab 2: TE Pricing (form -> agent decides tools -> structured output + explanation)
-- Tab 3: Logs (tail)
-
-Hugging Face:
-- Rename this file to app.py
-- Use requirements_langgraph.txt as requirements.txt
-- Add OPENAI_API_KEY in Space secrets
-
-Security:
-- This file redacts API keys from logs and UI outputs.
-
-Note:
-- "Benchmark research" here is AI-generated only. No browsing. Treat as draft until verified.
-
-"""
-
 from __future__ import annotations
 
 import json
+import math
 import os
-import re
+import sys
 import time
 import uuid
-import sqlite3
-from dataclasses import asdict, dataclass, field
+import traceback
+from dataclasses import dataclass, asdict, field
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
+import numpy as np
+import pandas as pd
+
+try:
+    from importlib.metadata import version as pkg_version
+except Exception:
+    pkg_version = None
+
+
+# =========================
+# HARD DEBUG: show what is running
+# =========================
+print("### THIS IS THE PURE PYTHON BUILD ###")
+
+print("\n========== HARD DEBUG BOOT ==========")
+print("RUNNING_FILE =", __file__)
+print("CWD =", os.getcwd())
+print("PYTHON =", sys.executable)
+if pkg_version:
+    for p in ["gradio", "numpy", "pandas"]:
+        try:
+            print(f"PKG {p} =", pkg_version(p))
+        except Exception as e:
+            print(f"PKG {p} = <missing> ({e})")
+print("=====================================\n")
+
 
 # =========================
-# IDs + versions (traceable)
+# Config + logging
 # =========================
 
 AGENT_ID = os.getenv("AGENT_ID", "nexdatawork_demo_agent")
-MODEL_ID = os.getenv("MODEL_ID", "framework_langgraph_agent")
+MODEL_ID = os.getenv("MODEL_ID", "pure_python_5step_debug")
 VERSION_ID = os.getenv("VERSION_ID", "1.0.0")
 
-POLICY_ID = os.getenv("POLICY_ID", "hitl_and_pricing_policy")
+POLICY_ID = os.getenv("POLICY_ID", "5step_workflow_policy")
 POLICY_VERSION = os.getenv("POLICY_VERSION", "1.0")
 
-LLM_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
-
-# Artifacts for HF Spaces
 DATA_DIR = Path(os.getenv("DATA_DIR", "./data"))
 DATA_DIR.mkdir(parents=True, exist_ok=True)
 RUN_LOG_PATH = DATA_DIR / os.getenv("RUN_LOG_PATH", "run_logs.jsonl")
-CHECKPOINT_PATH = DATA_DIR / os.getenv("CHECKPOINT_PATH", "checkpoints.sqlite")
 
-# FinTech policy knobs
-RISK_THRESHOLD = float(os.getenv("RISK_THRESHOLD", "0.50"))
-BORDER_BAND = float(os.getenv("BORDER_BAND", "0.05"))
+DEFAULT_SYNTHETIC_SEED = 42
 HIGH_IMPACT_AMOUNT = float(os.getenv("HIGH_IMPACT_AMOUNT", "1000000"))
-
-# TE pricing defaults
-DEFAULT_COGS = float(os.getenv("DEFAULT_COGS", "6"))
-DEFAULT_LANDED = float(os.getenv("DEFAULT_LANDED", "10"))
-DEFAULT_PRESALE_MULT = float(os.getenv("DEFAULT_PRESALE_MULT", "7"))
-DEFAULT_PRESALE_DISCOUNT = float(os.getenv("DEFAULT_PRESALE_DISCOUNT", "0.20"))
-DEFAULT_PRICE_GRID = [x for x in range(42, 121, 1)]  # 42..120 (demo grid)
+DEFAULT_PRICE_GRID = [x for x in range(42, 121, 1)]
 
 
-# =========================
-# Helpers
-# =========================
-
 def utc_now() -> str:
     return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
 
@@ -83,7 +66,17 @@ def new_id(prefix: str) -> str:
     ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
     return f"{prefix}_{ts}_{uuid.uuid4().hex[:8]}"
 
-def run_metadata(task_type: str) -> Dict[str, Any]:
+def clamp(x: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, x))
+
+def sigmoid(x: float) -> float:
+    if x >= 0:
+        z = math.exp(-x)
+        return 1.0 / (1.0 + z)
+    z = math.exp(x)
+    return z / (1.0 + z)
+
+def run_metadata(task_type: str, thread_id: str) -> Dict[str, Any]:
     return {
         "run_id": new_id("run"),
         "agent_id": AGENT_ID,
@@ -91,60 +84,22 @@ def run_metadata(task_type: str) -> Dict[str, Any]:
         "version_id": VERSION_ID,
         "policy_id": POLICY_ID,
         "policy_version": POLICY_VERSION,
-        "llm_model": LLM_MODEL,
         "task_type": task_type,
+        "thread_id": thread_id,
         "timestamps": {"created_at": utc_now()},
     }
 
 
-# =========================
-# Redaction (API key safety)
-# =========================
-
-_API_KEY_PATTERN = re.compile(r"sk-[A-Za-z0-9_\-]{20,}")
-
-def redact_text(s: str) -> str:
-    if not isinstance(s, str):
-        return s
-    return _API_KEY_PATTERN.sub("sk-REDACTED", s)
-
-def redact(obj: Any) -> Any:
-    if isinstance(obj, str):
-        return redact_text(obj)
-    if isinstance(obj, list):
-        return [redact(x) for x in obj]
-    if isinstance(obj, dict):
-        return {k: redact(v) for k, v in obj.items()}
-    return obj
-
-
-# =========================
-# Traceable logs
-# =========================
-
-@dataclass
-class StepTrace:
-    step_id: str
-    name: str
-    started_at: str
-    ended_at: str
-    duration_ms: int
-    inputs: Dict[str, Any] = field(default_factory=dict)
-    outputs: Dict[str, Any] = field(default_factory=dict)
-    evidence: Dict[str, Any] = field(default_factory=dict)
-    error: Optional[str] = None
-
-class TraceLogger:
+class JSONLLogger:
     def __init__(self, path: Path):
         self.path = path
         self.path.parent.mkdir(parents=True, exist_ok=True)
 
-    def log(self, payload: Dict[str, Any]) -> None:
-        payload = redact(payload)
+    def append(self, payload: Dict[str, Any]) -> None:
         with self.path.open("a", encoding="utf-8") as f:
             f.write(json.dumps(payload, ensure_ascii=False) + "\n")
 
-    def tail(self, n: int = 30) -> List[Dict[str, Any]]:
+    def tail(self, n: int = 50) -> List[Dict[str, Any]]:
         if not self.path.exists():
             return []
         lines = self.path.read_text(encoding="utf-8").splitlines()
@@ -156,89 +111,177 @@ class TraceLogger:
                 continue
         return out
 
-LOGGER = TraceLogger(RUN_LOG_PATH)
+LOGGER = JSONLLogger(RUN_LOG_PATH)
+
+
+@dataclass
+class StepTrace:
+    step_id: str
+    step_no: int
+    title: str
+    function_called: str
+    started_at: str
+    ended_at: str
+    duration_ms: int
+    evidence: Dict[str, Any] = field(default_factory=dict)
+    error: Optional[str] = None
+
+
+def run_step(step_no: int, title: str, function_called: str, fn) -> Tuple[StepTrace, Any]:
+    step_id = new_id("step")
+    started = utc_now()
+    t0 = time.time()
+    err = None
+    out = None
+    evidence: Dict[str, Any] = {}
+    try:
+        out = fn()
+        if isinstance(out, dict):
+            evidence = out
+        else:
+            evidence = {"value": out}
+    except Exception:
+        err = traceback.format_exc()
+    ended = utc_now()
+    dur = int((time.time() - t0) * 1000)
+    return StepTrace(
+        step_id=step_id,
+        step_no=step_no,
+        title=title,
+        function_called=function_called,
+        started_at=started,
+        ended_at=ended,
+        duration_ms=dur,
+        evidence=evidence,
+        error=err,
+    ), out
 
 
 # =========================
-# Deterministic "model tools" (evidence-friendly)
+# FINTECH pure python
 # =========================
 
-def fintech_score_tool(income: float, debt: float, credit_score: int) -> Dict[str, Any]:
-    """
-    Baseline, interpretable risk score:
-    risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)
-    """
-    if income <= 0:
-        raise ValueError("income must be > 0")
-    if debt < 0:
-        raise ValueError("debt must be >= 0")
-    if not (300 <= credit_score <= 850):
-        raise ValueError("credit_score must be between 300 and 850")
-
-    dti = debt / income
-    gap = (850 - credit_score) / 850
-    risk = (0.6 * dti) + (0.4 * gap)
+def fintech_build_row(inp: Dict[str, Any]) -> pd.DataFrame:
+    return pd.DataFrame([{
+        "Income": inp["income"],
+        "Debt": inp["debt"],
+        "Credit_Score": inp["credit_score"],
+        "Employment_Status": inp["employment_status"],
+        "Missed_Payments_12m": inp["missed_payments_12m"],
+        "Months_On_Book": inp["months_on_book"],
+        "Credit_Lines": inp["credit_lines"],
+        "Requested_Amount": inp["requested_amount"],
+    }])
+
+def synthetic_fill_numeric(df: pd.DataFrame, col: str, seed: int = DEFAULT_SYNTHETIC_SEED) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    rng = np.random.default_rng(seed)
+    out = df.copy()
+    s = pd.to_numeric(out[col], errors="coerce")
+    na = s.isna()
+    if not na.any():
+        return out, {"column": col, "filled": 0, "method": "none"}
+    observed = s.dropna()
+    observed = observed[observed >= 0]
+    n_missing = int(na.sum())
+
+    if len(observed) < 10:
+        base = rng.lognormal(mean=np.log(60000), sigma=0.7, size=n_missing) if col.lower().startswith("inc") \
+            else rng.lognormal(mean=np.log(8000), sigma=0.9, size=n_missing)
+        gen = base
+        method = "fallback_lognormal"
+    else:
+        q_low, q_high = observed.quantile([0.01, 0.99])
+        low = max(float(q_low) * 0.5, 0.0)
+        high = float(q_high) * 2.0
+        obs_pos = observed[observed > 0]
+        logx = np.log(obs_pos.to_numpy()) if len(obs_pos) else np.array([math.log(1.0)])
+        mu = float(logx.mean())
+        sigma = float(max(logx.std(ddof=1), 1e-6))
+        gen = rng.lognormal(mean=mu, sigma=sigma, size=n_missing)
+        gen = np.clip(gen, low, high)
+        method = "lognormal"
+
+    gen = np.rint(gen).astype(int)
+    gen = np.maximum(gen, 0)
+    out.loc[na, col] = gen
+    return out, {"column": col, "filled": n_missing, "method": method, "observed_n": int(len(observed))}
+
+def fintech_preprocess(df: pd.DataFrame, include_synth: bool) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    out = df.copy()
+    audits: List[Dict[str, Any]] = []
+    missing_before = out.isna().sum().astype(int).to_dict()
+
+    if include_synth:
+        for col in ["Income", "Debt"]:
+            out, audit = synthetic_fill_numeric(out, col)
+            audits.append(audit)
+
+    for col in out.columns:
+        if pd.api.types.is_numeric_dtype(out[col]):
+            if out[col].isna().any():
+                med = pd.to_numeric(out[col], errors="coerce").median()
+                out[col] = pd.to_numeric(out[col], errors="coerce").fillna(med)
+        else:
+            if out[col].isna().any():
+                mode = out[col].dropna().mode()
+                fillv = mode.iloc[0] if len(mode) else "Unknown"
+                out[col] = out[col].fillna(fillv)
+
+    missing_after = out.isna().sum().astype(int).to_dict()
+    return out, {"missing_before": missing_before, "missing_after": missing_after, "fill_audit": audits[:6]}
+
+def fintech_features(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    out["DTI"] = (out["Debt"] / out["Income"]).clip(lower=0, upper=5)
+    out["Score_Gap"] = ((850 - out["Credit_Score"]) / 550).clip(lower=0, upper=1)
+    out["Missed_Norm"] = (out["Missed_Payments_12m"].clip(lower=0, upper=12) / 12.0)
+    out["Tenure_Norm"] = (out["Months_On_Book"].clip(lower=0, upper=120) / 120.0)
+    out["Lines_Norm"] = (out["Credit_Lines"].clip(lower=0, upper=20) / 20.0)
+
+    emp = out["Employment_Status"].astype(str).str.lower().str.strip()
+    emp_w = emp.map({
+        "employed": 0.00, "self-employed": 0.05, "student": 0.08, "unemployed": 0.18,
+        "retired": 0.04, "contract": 0.06, "other": 0.07
+    }).fillna(0.07)
+    out["Employment_Risk_Weight"] = emp_w
+    return out
+
+def fintech_score(df_feat: pd.DataFrame) -> Dict[str, Any]:
+    dti = float(df_feat.loc[0, "DTI"])
+    gap = float(df_feat.loc[0, "Score_Gap"])
+    missed = float(df_feat.loc[0, "Missed_Norm"])
+    tenure = float(df_feat.loc[0, "Tenure_Norm"])
+    lines = float(df_feat.loc[0, "Lines_Norm"])
+    emp_w = float(df_feat.loc[0, "Employment_Risk_Weight"])
+
+    x = -1.20 + 1.60*dti + 1.40*gap + 1.10*missed + 0.90*emp_w - 0.40*tenure - 0.25*lines
+    pd_risk = sigmoid(x)
+    confidence = float(clamp(abs(pd_risk - 0.5) * 200.0, 0.0, 100.0))
+
+    req_amt = float(df_feat.loc[0, "Requested_Amount"])
+    bump = 0.0
+    if HIGH_IMPACT_AMOUNT > 0 and req_amt > 0:
+        ratio = req_amt / HIGH_IMPACT_AMOUNT
+        bump = 20.0 * clamp(math.log10(ratio + 1.0) / math.log10(11.0), 0.0, 1.0)
+
+    hitl = float(clamp((100.0 - confidence) * 0.75 + bump, 0.0, 100.0))
+    return {"pd_risk": pd_risk, "confidence_0_100": confidence, "hitl_urgency_0_100": hitl, "linear_x": x}
+
+def fintech_recommend(score: Dict[str, Any]) -> Dict[str, Any]:
+    decision = "Needs Human Review" if (score["hitl_urgency_0_100"] >= 60.0 or score["confidence_0_100"] <= 25.0) else "Decision Draft"
+    return {"decision": decision}
 
-    return {
-        "risk_score_pd": float(risk),
-        "intermediates": {"debt_to_income": float(dti), "score_gap": float(gap)},
-        "formula": "risk = 0.6*(debt/income) + 0.4*((850-credit_score)/850)",
-    }
-
-def hitl_policy(risk_score_pd: float, requested_amount: float) -> Dict[str, Any]:
-    """
-    HITL gating:
-    - High impact -> review
-    - High risk -> review
-    - Borderline -> review
-    - Else -> draft
-    """
-    thr = RISK_THRESHOLD
-    band = BORDER_BAND
-    hi = requested_amount >= HIGH_IMPACT_AMOUNT
-
-    if hi:
-        return {"decision": "Needs Human Review", "reason": "HIGH_IMPACT_CASE", "threshold": thr, "band": band}
-    if risk_score_pd >= (thr + band):
-        return {"decision": "Needs Human Review", "reason": "HIGH_RISK", "threshold": thr, "band": band}
-    if (thr - band) <= risk_score_pd < (thr + band):
-        return {"decision": "Needs Human Review", "reason": "BORDERLINE_SCORE", "threshold": thr, "band": band}
-    return {"decision": "Decision Draft", "reason": "LOW_RISK", "threshold": thr, "band": band}
-
-def te_pricing_tool(
-    cogs: float,
-    landed: float,
-    presale_mult: float,
-    discount: float,
-    alpha: float = 120.0,
-    beta: float = 0.08,
-) -> Dict[str, Any]:
-    """
-    Consumer product pricing demo (predictive modeling placeholder):
-    - Demand curve placeholder: demand = alpha * exp(-beta * price)
-    - Objective: maximize (price - landed) * demand across a grid
-    - Constraint: presale >= presale_mult * cogs, and presale >= 7*cogs (company rule)
-    - Retail: retail = presale / (1 - discount), retail > presale
-    """
-    if cogs <= 0:
-        raise ValueError("cogs must be > 0")
-    if landed <= 0:
-        raise ValueError("landed must be > 0")
-    if presale_mult < 1:
-        raise ValueError("presale_mult must be >= 1")
-    if not (0.0 < discount < 0.9):
-        raise ValueError("discount must be in (0, 0.9)")
-
-    floor = presale_mult * cogs
-    grid = [p for p in DEFAULT_PRICE_GRID if p >= floor]
 
-    # exp without extra deps
-    def exp(x: float) -> float:
-        return float((2.718281828459045) ** x)
+# =========================
+# TE pricing
+# =========================
 
+def te_grid_demand(cogs: float, landed: float, mult: float, discount: float, alpha: float, beta: float) -> Dict[str, Any]:
+    floor = mult * cogs
+    grid = [p for p in DEFAULT_PRICE_GRID if p >= floor]
     best = None
     for p in grid:
-        demand = float(alpha * exp(-beta * p))
+        demand = float(alpha * math.exp(-beta * p))
         profit = (p - landed) * demand
         if best is None or profit > best["objective_profit"]:
             best = {"presale": float(p), "demand": float(demand), "objective_profit": float(profit)}
@@ -246,7 +289,6 @@ def te_pricing_tool(
     presale = float(best["presale"]) if best else float(floor)
     retail = presale / (1.0 - discount)
 
-    # round to .99
     def as_99(x: float) -> float:
         v = round(x)
         return float(f"{max(v, 1) - 0.01:.2f}")
@@ -254,308 +296,231 @@ def te_pricing_tool(
     presale = as_99(presale)
     retail = as_99(retail)
 
-    checks = {
-        "presale_ge_floor": bool(presale >= floor),
-        "presale_ge_7xcogs": bool(presale >= 7.0 * cogs),
-        "retail_gt_presale": bool(retail > presale),
-    }
-
     return {
-        "inputs": {"cogs": cogs, "landed": landed, "presale_mult": presale_mult, "discount": discount, "alpha": alpha, "beta": beta},
         "presale_price": presale,
         "retail_price": retail,
-        "unit_margin_presale": presale - landed,
-        "unit_margin_retail": retail - landed,
+        "unit_margin_presale": float(presale - landed),
+        "unit_margin_retail": float(retail - landed),
+        "checks": {
+            "presale_ge_7xcogs": presale >= 7.0 * cogs,
+            "retail_gt_presale": retail > presale,
+        },
         "optimization": best,
-        "policy_checks": checks,
-        "demand_model": "alpha * exp(-beta * price) (placeholder)",
-        "notes": "Replace alpha/beta with real presale conversion or fitted demand model.",
     }
 
-def te_benchmark_placeholder() -> Dict[str, Any]:
-    """
-    No browsing in this demo. Provide a safe placeholder list.
-    The OpenAI agent can draft an unverified benchmark list (marked as draft).
-    """
-    return {
-        "benchmark_items": [
-            {"category": "smart_plug", "brand": "TP-Link Kasa"},
-            {"category": "smart_plug", "brand": "Amazon Smart Plug"},
-            {"category": "in_wall_outlet", "brand": "Leviton Decora Smart"},
-            {"category": "premium", "brand": "Eve (Matter/Thread)"},
-        ],
-        "limitations": "Placeholder only. Verify with real market data.",
-    }
-
-
-# =========================
-# LangChain tools (for ReAct agent)
-# =========================
-
-def build_tools():
-    from langchain_core.tools import tool
-
-    @tool("fintech_score")
-    def fintech_score(income: float, debt: float, credit_score: int) -> str:
-        """Compute a baseline risk score (PD) with intermediates. Returns JSON string."""
-        out = fintech_score_tool(income, debt, credit_score)
-        return json.dumps(out)
-
-    @tool("hitl_route")
-    def hitl_route(score_pd: float, requested_amount: float) -> str:
-        """Apply HITL policy routing. Returns JSON string."""
-        out = hitl_policy(score_pd, requested_amount)
-        return json.dumps(out)
-
-    @tool("te_pricing")
-    def te_pricing(cogs: float, landed: float, presale_mult: float, discount: float) -> str:
-        """Compute presale + retail pricing under constraints. Returns JSON string."""
-        out = te_pricing_tool(cogs, landed, presale_mult, discount)
-        return json.dumps(out)
-
-    @tool("te_benchmark_placeholder")
-    def te_benchmark() -> str:
-        """Return a placeholder competitor benchmark list. Returns JSON string."""
-        return json.dumps(te_benchmark_placeholder())
-
-    return [fintech_score, hitl_route, te_pricing, te_benchmark]
-
-
-# =========================
-# LangGraph agent with memory (thread_id)
-# =========================
-
-def build_checkpointer():
-    """
-    Use SQLite checkpointer if available; otherwise memory.
-    We use SqliteSaver(conn) to avoid context-manager issues.
-    """
-    try:
-        from langgraph.checkpoint.sqlite import SqliteSaver
-        conn = sqlite3.connect(str(CHECKPOINT_PATH), check_same_thread=False)
-        return SqliteSaver(conn), "sqlite"
-    except Exception:
-        from langgraph.checkpoint.memory import InMemorySaver
-        return InMemorySaver(), "memory"
 
-CHECKPOINTER, CHECKPOINTER_KIND = build_checkpointer()
-
-def build_agent():
-    """
-    Create a tool-calling ReAct agent with memory.
-    This follows the LangGraph "add memory" pattern using a checkpointer keyed by thread_id.
-    """
-    from langchain_openai import ChatOpenAI
+FIVE_STEP_TITLES = [
+    "Interpreting Context & Metrics",
+    "Pre-Processing Data",
+    "Processing Data",
+    "Analyzing Data",
+    "Trend Analysis & Predictions",
+]
+
+def report_5step(title: str, final_summary: Dict[str, Any], steps: List[StepTrace]) -> str:
+    md = []
+    md.append(f"## {title}\n")
+    md.append("### Final")
+    for k, v in final_summary.items():
+        md.append(f"- {k}: **{v}**")
+
+    md.append("\n### Five steps")
+    for s in steps:
+        md.append(f"**Step {s.step_no}. {s.title}**")
+        md.append(f"- function: `{s.function_called}`")
+        md.append(f"- step_id: `{s.step_id}`")
+        md.append(f"- duration_ms: `{s.duration_ms}`")
+        if s.error:
+            md.append(f"\n```text\n{s.error}\n```\n")
+        else:
+            md.append(f"- evidence: `{s.evidence}`\n")
+    return "\n".join(md).strip()
+
+
+def run_fintech_case(thread_id: str, inp: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    meta = run_metadata("fintech", thread_id)
+    steps: List[StepTrace] = []
 
-    llm = ChatOpenAI(model=LLM_MODEL, temperature=0)
+    s1, _ = run_step(1, FIVE_STEP_TITLES[0], "fintech_build_row", lambda: {"inputs": inp})
+    steps.append(s1)
+    df_raw = fintech_build_row(inp)
 
-    tools = build_tools()
+    s2, _ = run_step(2, FIVE_STEP_TITLES[1], "fintech_preprocess", lambda: fintech_preprocess(df_raw, bool(inp.get("include_synth", True)))[1])
+    steps.append(s2)
+    df_clean, prep = fintech_preprocess(df_raw, bool(inp.get("include_synth", True)))
 
-    # Compatibility: create_react_agent moved across versions.
-    try:
-        from langgraph.prebuilt import create_react_agent  # older path
-        agent = create_react_agent(llm, tools, checkpointer=CHECKPOINTER)
-        return agent
-    except Exception:
-        # Newer versions may not have prebuilt; fallback to langchain.agents
-        from langchain.agents import create_react_agent as lc_create_react_agent
-        agent = lc_create_react_agent(llm, tools)
-        return agent
+    s3, _ = run_step(3, FIVE_STEP_TITLES[2], "fintech_features", lambda: {"features": fintech_features(df_clean)[["DTI","Score_Gap","Missed_Norm","Tenure_Norm","Employment_Risk_Weight"]].iloc[0].to_dict()})
+    steps.append(s3)
+    df_feat = fintech_features(df_clean)
 
-AGENT = None
+    s4, score = run_step(4, FIVE_STEP_TITLES[3], "fintech_score", lambda: fintech_score(df_feat))
+    steps.append(s4)
 
-def get_agent():
-    global AGENT
-    if AGENT is None:
-        AGENT = build_agent()
-    return AGENT
+    s5, rec = run_step(5, FIVE_STEP_TITLES[4], "fintech_recommend", lambda: fintech_recommend(score))
+    steps.append(s5)
 
+    final = {
+        "Decision": rec["decision"],
+        "PD risk": f"{score['pd_risk']:.3f}",
+        "Confidence": f"{score['confidence_0_100']:.1f}/100",
+        "HITL urgency": f"{score['hitl_urgency_0_100']:.1f}/100",
+    }
+    report = report_5step("FinTech Credit Risk", final, steps)
 
-# =========================
-# Agent runner (traceable wrapper)
-# =========================
+    payload = {**meta, "inputs": inp, "steps": [asdict(x) for x in steps], "outputs": {"score": score, "recommendation": rec, "prep": prep}}
+    LOGGER.append(payload)
+    return report, payload
 
-def invoke_agent(thread_id: str, task_type: str, user_prompt: str) -> Dict[str, Any]:
-    """
-    Run the agent under a thread_id, record a traceable payload, return payload.
-    """
-    meta = run_metadata(task_type)
+def run_te_case(thread_id: str, inp: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    meta = run_metadata("te_pricing", thread_id)
     steps: List[StepTrace] = []
 
-    # Step: memory touch (invoke a noop by reading state indirectly)
-    # We rely on checkpointer in agent; we still record thread_id + checkpointer kind as evidence.
-    steps.append(StepTrace(
-        step_id=new_id("step"),
-        name="memory_scope",
-        started_at=utc_now(),
-        ended_at=utc_now(),
-        duration_ms=0,
-        inputs={"thread_id": thread_id},
-        outputs={"checkpointer_kind": CHECKPOINTER_KIND},
-        evidence={"note": "Memory is keyed by thread_id via LangGraph checkpointer."},
-    ))
-
-    agent = get_agent()
+    s1, _ = run_step(1, FIVE_STEP_TITLES[0], "te_context", lambda: {"inputs": inp})
+    steps.append(s1)
 
-    t0 = time.time()
-    err = None
-    raw = ""
-    try:
-        config = {"configurable": {"thread_id": thread_id}}
-        result = agent.invoke({"messages": [{"role": "user", "content": user_prompt}]}, config=config)
-        raw = result["messages"][-1].content if result and "messages" in result else ""
-        raw = redact_text(raw)
-    except Exception as e:
-        err = redact_text(str(e))
-
-    steps.append(StepTrace(
-        step_id=new_id("step"),
-        name="agent_invoke",
-        started_at=utc_now(),
-        ended_at=utc_now(),
-        duration_ms=int((time.time() - t0) * 1000),
-        inputs={"task_type": task_type},
-        outputs={"raw_text_preview": raw[:2000]},
-        error=err,
-        evidence={"llm_model": LLM_MODEL},
-    ))
-
-    payload = {
-        **meta,
-        "decision": "Needs Human Review" if err else "Draft",
-        "result": {"raw_text": raw, "error": err},
-        "evidence": {"steps": [asdict(s) for s in steps]},
-    }
+    s2, _ = run_step(2, FIVE_STEP_TITLES[1], "te_input_checks", lambda: {
+        "checks": {"cogs_gt_0": inp["cogs"] > 0, "landed_gt_0": inp["landed"] > 0, "discount_range": 0.0 < inp["discount"] < 0.9}
+    })
+    steps.append(s2)
 
-    LOGGER.log(payload)
-    return redact(payload)
+    s3, _ = run_step(3, FIVE_STEP_TITLES[2], "te_derive", lambda: {
+        "presale_floor": max(inp["presale_mult"] * inp["cogs"], 7.0 * inp["cogs"]),
+        "implied_retail_floor": max(inp["presale_mult"] * inp["cogs"], 7.0 * inp["cogs"]) / (1.0 - inp["discount"]),
+    })
+    steps.append(s3)
 
+    s4, pricing = run_step(4, FIVE_STEP_TITLES[3], "te_grid_demand", lambda: te_grid_demand(inp["cogs"], inp["landed"], inp["presale_mult"], inp["discount"], inp["alpha"], inp["beta"]))
+    steps.append(s4)
 
-# =========================
-# Prompt templates (keep it simple + tool-focused)
-# =========================
+    s5, _ = run_step(5, FIVE_STEP_TITLES[4], "te_summary", lambda: {"presale": pricing["presale_price"], "retail": pricing["retail_price"], "checks": pricing["checks"]})
+    steps.append(s5)
 
-def fintech_prompt(income: float, debt: float, credit_score: int, requested_amount: float) -> str:
-    return f"""
-You are running the FinTech credit risk demo.
-Use tools in this order:
-1) fintech_score(income, debt, credit_score)
-2) hitl_route(score_pd, requested_amount)
-
-Then return:
-- A short decision summary (Decision Draft vs Needs Human Review) and the reason.
-- Include the tool JSON outputs in the response (copy them).
-Inputs:
-income={income}
-debt={debt}
-credit_score={credit_score}
-requested_amount={requested_amount}
-""".strip()
-
-def te_pricing_prompt(cogs: float, landed: float, mult: float, discount: float) -> str:
-    return f"""
-You are running the TE pricing demo (consumer product use case).
-Constraints:
-- presale >= 7 * COGS
-- retail > presale
-Use tools:
-1) te_pricing(cogs, landed, presale_mult, discount)
-2) te_benchmark_placeholder()
-
-Then return:
-- Suggested presale and retail prices (from tool output)
-- Policy checks status
-- A short note on what data we need to make the demand model more accurate
-Inputs:
-cogs={cogs}
-landed={landed}
-presale_mult={mult}
-discount={discount}
-""".strip()
+    final = {"Presale": pricing["presale_price"], "Retail": pricing["retail_price"], "Checks": pricing["checks"]}
+    report = report_5step("TE Pricing", final, steps)
+
+    payload = {**meta, "inputs": inp, "steps": [asdict(x) for x in steps], "outputs": {"pricing": pricing}}
+    LOGGER.append(payload)
+    return report, payload
 
 
 # =========================
-# Gradio UI
+# UI (debug: always show traceback)
 # =========================
 
 def build_gradio_app():
     import gradio as gr
 
-    def run_fintech(income, debt, credit_score, requested_amount, thread_id):
-        prompt = fintech_prompt(float(income), float(debt), int(credit_score), float(requested_amount))
-        payload = invoke_agent(thread_id=str(thread_id), task_type="fintech_credit_risk", user_prompt=prompt)
-        return payload["run_id"], json.dumps(payload, indent=2)
-
-    def run_te(cogs, landed, mult, discount, thread_id):
-        prompt = te_pricing_prompt(float(cogs), float(landed), float(mult), float(discount))
-        payload = invoke_agent(thread_id=str(thread_id), task_type="te_pricing", user_prompt=prompt)
-        return payload["run_id"], json.dumps(payload, indent=2)
-
-    def view_logs(n):
+    STATE: Dict[str, Any] = {"last_payload": None}
+    emp_choices = ["Employed", "Self-employed", "Student", "Unemployed", "Retired", "Contract", "Other"]
+
+    def safe_call(fn):
+        try:
+            return fn()
+        except Exception:
+            tb = traceback.format_exc()
+            print(tb)
+            return "ERROR:\n\n```text\n" + tb + "\n```"
+
+    def ui_fintech(income, debt, credit_score, employment_status, missed_12m, months_on_book, credit_lines, requested_amount, include_synth, thread_id):
+        def _do():
+            inp = {
+                "income": float(income),
+                "debt": float(debt),
+                "credit_score": int(credit_score),
+                "employment_status": str(employment_status),
+                "missed_payments_12m": int(missed_12m),
+                "months_on_book": int(months_on_book),
+                "credit_lines": int(credit_lines),
+                "requested_amount": float(requested_amount),
+                "include_synth": bool(include_synth),
+            }
+            report, payload = run_fintech_case(str(thread_id), inp)
+            STATE["last_payload"] = payload
+            return report
+        return safe_call(_do)
+
+    def ui_te(cogs, landed, mult, discount, alpha, beta, thread_id):
+        def _do():
+            inp = {
+                "cogs": float(cogs),
+                "landed": float(landed),
+                "presale_mult": float(mult),
+                "discount": float(discount),
+                "alpha": float(alpha),
+                "beta": float(beta),
+            }
+            report, payload = run_te_case(str(thread_id), inp)
+            STATE["last_payload"] = payload
+            return report
+        return safe_call(_do)
+
+    def ui_current_trace():
+        p = STATE.get("last_payload")
+        if not p:
+            return "No run yet."
+        return json.dumps(p, indent=2)
+
+    def ui_logs(n):
         return json.dumps(LOGGER.tail(int(n)), indent=2)
 
-    with gr.Blocks(title="Demo B") as demo:
-        gr.Markdown(
-            "## LangGraph Memory + Traceable Demo\n"
-            "This demo shows a LangGraph/LangChain agent with memory (thread_id) and traceable run logs.\n"
-            f"- Checkpointer: **{CHECKPOINTER_KIND}**\n"
-        )
-
+    with gr.Blocks(title="Demo") as demo:
         with gr.Row():
-            thread_id = gr.Textbox(value="demo_thread", label="thread_id (memory scope)")
-            gr.Markdown(f"Logs: `{RUN_LOG_PATH}`  \nCheckpoints: `{CHECKPOINT_PATH}`")
+            thread_id = gr.Textbox(value="demo_thread", label="thread_id")
 
         with gr.Tabs():
-            with gr.Tab("FinTech: Credit Risk Demo"):
-                gr.Markdown("Simple form. Agent calls tools and returns a traceable payload.")
+            with gr.Tab("FinTech"):
                 with gr.Row():
-                    income = gr.Number(value=75000, label="Income (annual)")
-                    debt = gr.Number(value=30000, label="Debt (total)")
-                    credit_score = gr.Number(value=680, label="Credit score (300-850)")
-                    requested_amount = gr.Number(value=250000, label="Requested amount")
-                btn = gr.Button("Run FinTech agent")
-                out_run = gr.Textbox(label="run_id")
-                out_json = gr.Textbox(label="traceable output JSON", lines=22)
-                btn.click(fn=run_fintech, inputs=[income, debt, credit_score, requested_amount, thread_id], outputs=[out_run, out_json])
-
-            with gr.Tab("TE: Pricing Demo"):
-                gr.Markdown(
-                    "Consumer product use case. Agent computes presale + retail under constraints and shows benchmark placeholder.\n"
-                    "For a real benchmark, replace placeholder with curated market dataset (or verified research)."
-                )
+                    with gr.Column(scale=5, min_width=460):
+                        income = gr.Number(value=75000, label="Income (annual)")
+                        debt = gr.Number(value=30000, label="Debt (total)")
+                        credit_score = gr.Number(value=680, label="Credit score (300-850)")
+                        requested_amount = gr.Number(value=250000, label="Requested amount")
+                        employment_status = gr.Dropdown(choices=emp_choices, value="Employed", label="Employment status")
+                        missed_12m = gr.Number(value=1, label="Missed payments (12m)")
+                        months_on_book = gr.Number(value=18, label="Months on book")
+                        credit_lines = gr.Number(value=4, label="Credit lines")
+                        include_synth = gr.Checkbox(value=True, label="Handle missing values (synthetic fill)")
+                        btn = gr.Button("Run", variant="primary")
+
+                    with gr.Column(scale=7, min_width=640):
+                        out = gr.Markdown(value="_(Run to see output.)_")
+
+                btn.click(fn=ui_fintech, inputs=[income, debt, credit_score, employment_status, missed_12m, months_on_book, credit_lines, requested_amount, include_synth, thread_id], outputs=[out])
+
+            with gr.Tab("TE"):
                 with gr.Row():
-                    cogs = gr.Number(value=DEFAULT_COGS, label="COGS per unit")
-                    landed = gr.Number(value=DEFAULT_LANDED, label="Landed cost per unit")
-                    mult = gr.Number(value=DEFAULT_PRESALE_MULT, label="Presale floor multiplier (>=7)")
-                    discount = gr.Slider(0.10, 0.40, value=DEFAULT_PRESALE_DISCOUNT, step=0.05, label="Presale discount vs retail")
-                btn2 = gr.Button("Run TE pricing agent")
-                out_run2 = gr.Textbox(label="run_id")
-                out_json2 = gr.Textbox(label="traceable output JSON", lines=22)
-                btn2.click(fn=run_te, inputs=[cogs, landed, mult, discount, thread_id], outputs=[out_run2, out_json2])
-
-            with gr.Tab("Trace Logs"):
+                    with gr.Column(scale=5, min_width=460):
+                        cogs = gr.Number(value=6, label="COGS per unit")
+                        landed = gr.Number(value=10, label="Landed cost per unit")
+                        mult = gr.Number(value=7, label="Presale floor multiplier")
+                        discount = gr.Number(value=0.20, label="Discount (0-0.9)")
+                        alpha = gr.Number(value=120, label="Demand alpha (placeholder)")
+                        beta = gr.Number(value=0.08, label="Demand beta (placeholder)")
+                        btn2 = gr.Button("Run", variant="primary")
+
+                    with gr.Column(scale=7, min_width=640):
+                        out2 = gr.Markdown(value="_(Run to see output.)_")
+
+                btn2.click(fn=ui_te, inputs=[cogs, landed, mult, discount, alpha, beta, thread_id], outputs=[out2])
+
+            with gr.Tab("Trace"):
+                btn3 = gr.Button("Show current run")
+                cur = gr.Code(language="json")
+                btn3.click(fn=ui_current_trace, inputs=[], outputs=[cur])
+
                 n = gr.Slider(10, 200, value=30, step=10, label="show last N runs")
-                btn3 = gr.Button("Refresh logs")
-                logs_out = gr.Textbox(lines=24, label="logs (JSON list)")
-                btn3.click(fn=view_logs, inputs=[n], outputs=[logs_out])
-
-        gr.Markdown(
-            "### Hugging Face deploy\n"
-            "1) Rename this file to `app.py`\n"
-            "2) Use the provided requirements file as `requirements.txt`\n"
-            "3) Add `OPENAI_API_KEY` in Space Secrets\n\n"
-            "Note: I can't provide a Hugging Face account for org access. Use your own HF username and ask to be added."
-        )
+                btn4 = gr.Button("Refresh logs")
+                logs = gr.Code(language="json")
+                btn4.click(fn=ui_logs, inputs=[n], outputs=[logs])
 
     return demo
 
 
 def main():
     demo = build_gradio_app()
-    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")), debug=True)
 
 
 if __name__ == "__main__":
     main()
-
-# http://localhost:7860 
+# http://localhost:7860 

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.31.0
+numpy>=1.24.0
+pandas>=2.0.0
+openai>=1.40.0
+scikit-learn>=1.3.0
+matplotlib>=3.8.0

requirements_demo_b.txt

@@ -1,7 +1,8 @@
-gradio>=4.0.0
-langgraph>=1.0.0
-langgraph-checkpoint>=1.0.0
-langgraph-checkpoint-sqlite>=1.0.0
-langchain-core>=0.2.0
-langchain-openai>=0.1.0
-openai>=1.0.0
+gradio>=4.31.0
+langgraph>=0.2.34
+langchain>=0.2.16
+langchain-core>=0.2.38
+langchain-openai>=0.1.22
+openai>=1.40.0
+numpy>=1.24.0
+pandas>=2.0.0