Update app.py

app.py

@@ -1,336 +1,338 @@
-
+import os, re, json, copy
 import gradio as gr
-import json, re, math
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 
-# --------------------
-# State/HUD structure
-# --------------------
-DEFAULTS = {
-    "model": "logistic",
-    # Logistic yield: Y(X) = L / (1 + exp(-k*(X - x0)))
-    "L": None,     # max yield
-    "k": None,     # slope
-    "x0": None,    # inflection X
-    # Prices & costs
-    "Px": None,    # input price ($/lb of fert)  -> MIC
-    "Py": None,    # output price ($/unit yield)
-    "Other": 0.0,  # other cost per acre (fixed wrt X)
-    # Range
-    "x_min": 0.0,
-    "x_max": 150.0,
-    "x_step": 5.0,
-    # Computed last table/plot
-    "table_ready": False,
-    "want_plot": False,
-    "last_table_cols": [],
-    "last_focus_x": None  # for showing sample calc on a specific X
+# ==========================
+# Jerry — Logistic Yield Coach (app52) in app53 style
+# - LLM-first parser (OpenAI GPT-5.0), regex fallback
+# - Schema JSON -> HUD merge -> requirements checks
+# - HUD reordered: Py, Px, Other, L, k, x0, range, which_action, last_focus_x
+# - Blackboard "show your work" at any X
+# ==========================
+
+# ---------- HUD FIELDS (ORDERED top→bottom) ----------
+HUD_FIELDS = [
+    "Py", "Px", "Other",
+    "L", "k", "x0",
+    "x_min", "x_max", "x_step",
+    "which_action",
+    "last_focus_x"
+]
+
+DEFAULTS = {k: None for k in HUD_FIELDS}
+DEFAULTS.update({"x_min": 0.0, "x_max": 150.0, "x_step": 5.0, "Other": 0.0})
+
+# ---------- Requirements per action ----------
+REQUIREMENTS = {
+    "table":   ["L","k","x0","x_min","x_max","x_step"],
+    "plot":    ["L","k","x0","x_min","x_max","x_step"],
+    "app":     ["L","k","x0","x_min","x_max","x_step"],
+    "mpp":     ["L","k","x0","x_min","x_max","x_step"],
+    "mvp":     ["L","k","x0","x_min","x_max","x_step","Py"],
+    "mic":     ["Px"],
+    "profit":  ["L","k","x0","x_min","x_max","x_step","Py","Px"],
+    "optimal": ["L","k","x0","x_min","x_max","x_step","Py","Px"],
+    "stage":   ["L","k","x0","x_min","x_max","x_step"],
+    "work":    ["L","k","x0"]
 }
 
-HELP = '''Say things like:
-- "use logistic: L=1200, k=0.06, x0=60"
-- "set Py=0.5 and Px=0.25 and other cost=300"
-- "range 0 to 150 by 5"
-- "make table"
-- "graph yield" (or "plot mpp" / "plot profit")
-- "compute APP" / "compute MPP" / "compute MVP" / "compute MIC"
-- "show production stages"
-- "calculate profit"
-- "find optimal" (uses rule MVP = MIC in Stage II)
-- "change Py to 0.6" or "change Px 0.3"
-'''
-
-# --------------------
-# Core economics
-# --------------------
+# ---------- Utils ----------
+def _pp(x):
+    try:
+        return json.dumps(x, indent=2, ensure_ascii=False, default=str)
+    except Exception:
+        return str(x)
+
+def merge_into_hud(hud: dict, new_data: dict):
+    """Overwrite HUD with any non-null values from new_data. Return (updated_hud, changed_keys)."""
+    base = copy.deepcopy(hud) if hud else copy.deepcopy(DEFAULTS)
+    changed = []
+    for k in HUD_FIELDS:
+        if k in new_data and new_data[k] is not None:
+            if base.get(k) != new_data[k]:
+                base[k] = new_data[k]
+                changed.append(k)
+    return base, changed
+
+def missing_for(action: str, hud: dict):
+    need = REQUIREMENTS.get(action or "", [])
+    miss = [k for k in need if hud.get(k) in (None, "", float("nan"))]
+    return miss
+
+# ---------- Model (logistic) ----------
 def Y_logistic(X, L, k, x0):
-    return L / (1.0 + np.exp(-k * (X - x0)))
+    return float(L) / (1.0 + np.exp(-float(k) * (X - float(x0))))
 
 def MPP_logistic(X, L, k, x0):
-    # derivative of logistic: dY/dX = L*k*exp(-k*(X - x0)) / (1 + exp(-k*(X - x0)))^2
-    e = np.exp(-k * (X - x0))
-    return L * k * e / (1.0 + e)**2
-
-def table_from_hud(hud):
-    L, k, x0 = hud["L"], hud["k"], hud["x0"]
-    x_min, x_max, x_step = hud["x_min"], hud["x_max"], hud["x_step"]
-    if None in (L, k, x0):
-        raise ValueError("Set logistic params first (L, k, x0).")
-    X = np.arange(float(x_min), float(x_max) + 1e-9, float(x_step))
-    Y = Y_logistic(X, L, k, x0)
-    APP = np.divide(Y, X, out=np.zeros_like(Y), where=X>0)
-    MPP = MPP_logistic(X, L, k, x0)
-    data = {
-        "X": X,
-        "Y": Y,
-        "APP": APP,
-        "MPP": MPP
-    }
-    # Add MVP, MIC, Profit if prices exist
-    if hud.get("Py") is not None:
-        data["MVP"] = MPP * float(hud["Py"])
-    if hud.get("Px") is not None:
-        data["MIC"] = np.full_like(X, float(hud["Px"]), dtype=float)
-    if hud.get("Py") is not None and hud.get("Px") is not None:
-        Other = float(hud.get("Other", 0.0))
-        data["Profit"] = Y * float(hud["Py"]) - X * float(hud["Px"]) - Other
+    e = np.exp(-float(k) * (X - float(x0)))
+    return float(L) * float(k) * e / (1.0 + e)**2
+
+def build_table(h):
+    L, k, x0 = float(h["L"]), float(h["k"]), float(h["x0"])
+    X = np.arange(float(h["x_min"]), float(h["x_max"]) + 1e-9, float(h["x_step"]))
+    Y = [Y_logistic(x,L,k,x0) for x in X]
+    APP = [y/x if x!=0 else 0 for x,y in zip(X,Y)]
+    MPP = [MPP_logistic(x,L,k,x0) for x in X]
+    data = {"X": X, "Y": Y, "APP": APP, "MPP": MPP}
+    if h.get("Py") is not None: data["MVP"] = [m*float(h["Py"]) for m in MPP]
+    if h.get("Px") is not None: data["MIC"] = [float(h["Px"])]*len(X)
+    if h.get("Py") is not None and h.get("Px") is not None:
+        data["Profit"] = [y*float(h["Py"]) - x*float(h["Px"]) - float(h.get("Other") or 0.0) for x,y in zip(X,Y)]
     df = pd.DataFrame(data)
-    # Stage classification
     stage = []
-    for i, row in df.iterrows():
+    for _, row in df.iterrows():
         if row["MPP"] > 0:
-            if row["APP"] >= row["MPP"]:
-                s = "I"
-            else:
-                s = "II"
+            stage.append("I" if row["APP"] >= row["MPP"] else "II")
         else:
-            s = "III"
-        stage.append(s)
+            stage.append("III")
     df["Stage"] = stage
     return df
 
-def find_optimal(hud):
-    # Find X that maximizes profit by MVP = MIC (Stage II)
-    df = table_from_hud(hud)
+def find_optimal(h):
+    df = build_table(h)
     if "MVP" not in df.columns or "MIC" not in df.columns:
         raise ValueError("Need Py (for MVP) and Px (for MIC).")
-    # Find index minimizing |MVP - MIC| with MPP>0 (Stage II)
-    mask = (df["Stage"] == "II")
-    if not mask.any():
-        # fallback: allow all
-        mask = df["MPP"] > 0
+    mask = (df["Stage"]=="II")
+    if not mask.any(): mask = df["MPP"]>0
     sub = df[mask].copy()
     sub["gap"] = (sub["MVP"] - sub["MIC"]).abs()
     j = sub["gap"].idxmin()
-    row = df.loc[j]
-    return row  # contains X, Y, Profit, etc.
-
-# --------------------
-# NLP parser
-# --------------------
-def parse(user, hud):
-    updated = []
-
-    txt = user.strip()
-
-    # logistic params
-    # "L=1200, k=0.06, x0=60" (order flexible)
-    mL = re.search(r'\bL\s*=\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    mk = re.search(r'\bk\s*=\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    mx0 = re.search(r'\bx0\s*=\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    if mL:
-        hud["L"] = float(mL.group(1)); updated.append("L")
-    if mk:
-        hud["k"] = float(mk.group(1)); updated.append("k")
-    if mx0:
-        hud["x0"] = float(mx0.group(1)); updated.append("x0")
-
-    if re.search(r'logistic', txt, flags=re.I):
-        hud["model"] = "logistic"; updated.append("model")
-
-    # prices
-    mPx = re.search(r'(?:Px|MIC|input price)\s*=?\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    mPy = re.search(r'(?:Py|output price)\s*=?\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    mOther = re.search(r'(?:Other|other cost)\s*=?\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    if mPx:
-        hud["Px"] = float(mPx.group(1)); updated.append("Px")
-    if mPy:
-        hud["Py"] = float(mPy.group(1)); updated.append("Py")
-    if mOther:
-        hud["Other"] = float(mOther.group(1)); updated.append("Other")
-
-    # quick "change Py to 0.6" etc.
-    mchg = re.search(r'change\s+(px|py|other)\s*(?:to|=)\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    if mchg:
-        key = mchg.group(1).title()
-        hud[key] = float(mchg.group(2)); updated.append(key)
-
-    # range
-    mrange = re.search(r'(?:range|fertilize|apply|from)\s*([0-9]*\.?[0-9]+)\s*(?:to|-)\s*([0-9]*\.?[0-9]+)\s*(?:by|in|step)\s*([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    if mrange:
-        hud["x_min"] = float(mrange.group(1)); updated.append("x_min")
-        hud["x_max"] = float(mrange.group(2)); updated.append("x_max")
-        hud["x_step"] = float(mrange.group(3)); updated.append("x_step")
-
-    # focus X for blackboard example: "at X=80" or "at 80 lbs"
-    mfocus = re.search(r'at\s*(?:x\s*=?\s*)?([0-9]*\.?[0-9]+)', txt, flags=re.I)
-    if mfocus:
-        hud["last_focus_x"] = float(mfocus.group(1)); updated.append("last_focus_x")
-
-    # intents
-    intent = None
-    if re.search(r'\bmake table|\btable', txt, flags=re.I):
-        intent = "table"
-    if re.search(r'graph|plot', txt, flags=re.I):
-        # accept "plot yield", "plot mpp", "plot profit", default "yield"
-        intent = "plot"
-    if re.search(r'compute\s+app|\bAPP\b', txt, flags=re.I):
-        intent = "app"
-    if re.search(r'compute\s+mpp|\bMPP\b', txt, flags=re.I):
-        intent = "mpp"
-    if re.search(r'compute\s+mvp|\bMVP\b', txt, flags=re.I):
-        intent = "mvp"
-    if re.search(r'compute\s+mic|\bMIC\b', txt, flags=re.I):
-        intent = "mic"
-    if re.search(r'profit', txt, flags=re.I):
-        intent = "profit"
-    if re.search(r'optimal|find optimal|mvp\s*=\s*mic', txt, flags=re.I):
-        intent = "optimal"
-    if re.search(r'stage', txt, flags=re.I):
-        intent = "stage"
-    if re.search(r'help', txt, flags=re.I):
-        intent = "help"
-
-    return hud, updated, intent, txt
-
-# --------------------
-# Blackboard examples
-# --------------------
-def sample_work(hud, df):
-    # Return a short textual sample calculation at a representative X.
-    if hud.get("last_focus_x") is not None:
-        x0 = hud["last_focus_x"]
-        j = int(round((x0 - hud["x_min"]) / hud["x_step"]))
-        j = max(0, min(j, len(df)-1))
-    else:
-        j = len(df)//2
-    row = df.iloc[j]
-    lines = []
-    lines.append(f"At X = {row['X']:.3g}:")
-    lines.append(f"  Y = L/(1+exp(-k*(X-x0))) with L={hud['L']}, k={hud['k']}, x0={hud['x0']}")
-    lines.append(f"  => Y ≈ {row['Y']:.4g}")
-    lines.append(f"  APP = Y/X ≈ {row['APP']:.4g}")
-    lines.append(f"  MPP = dY/dX ≈ {row['MPP']:.4g}")
-    if 'MVP' in df.columns:
-        lines.append(f"  MVP = MPP·Py ≈ {row['MVP']:.4g}")
-    if 'MIC' in df.columns:
-        lines.append(f"  MIC = Px ≈ {row['MIC']:.4g}")
-    if 'Profit' in df.columns:
-        lines.append(f"  Profit = Py·Y − Px·X − Other ≈ {row['Profit']:.4g}")
+    return df.loc[j], df
+
+def row_at_x(h, x):
+    L, k, x0 = float(h["L"]), float(h["k"]), float(h["x0"])
+    x = float(x)
+    Y = Y_logistic(x,L,k,x0)
+    APP = Y/x if x!=0 else 0.0
+    MPP = MPP_logistic(x,L,k,x0)
+    out = {"X":x,"Y":Y,"APP":APP,"MPP":MPP}
+    if h.get("Py") is not None: out["MVP"] = MPP*float(h["Py"])
+    if h.get("Px") is not None: out["MIC"] = float(h["Px"])
+    if h.get("Py") is not None and h.get("Px") is not None:
+        out["Profit"] = Y*float(h["Py"]) - x*float(h["Px"]) - float(h.get("Other") or 0.0)
+    out["Stage"] = "I" if MPP>0 and APP>=MPP else "II" if MPP>0 else "III"
+    return pd.DataFrame([out])
+
+# ---------- LLM-first parser (OpenAI GPT-5.0), regex fallback ----------
+from openai import OpenAI
+
+client = OpenAI()
+LLM_OK = bool(os.getenv("OPENAI_API_KEY"))
+
+JERRY_SYSTEM_PROMPT = (
+    "You are JERRY, a production economics coach. "
+    "Read the student's text and output ONLY a minified JSON object with keys: "
+    "Py, Px, Other, L, k, x0, x_min, x_max, x_step, which_action, last_focus_x. "
+    "Strip units like $, %, lbs, etc. Use numerals. "
+    "Map actions: 'plot/graph'->'plot', 'make table'->'table', "
+    "'find optimal' or 'MVP=MIC'->'optimal', 'compute mpp'->'mpp', "
+    "'compute app'->'app', 'compute mvp'->'mvp', 'compute mic'->'mic', "
+    "'profit'->'profit', 'stage(s)'->'stage', "
+    "'show work at X=...' or 'explain ...'->'work' with last_focus_x set."
+)
+
+def llm_parse(user: str):
+    if not LLM_OK:
+        return {}
+    try:
+        resp = client.chat.completions.create(
+            model="gpt-5.0",
+            temperature=0,
+            messages=[
+                {"role": "system", "content": JERRY_SYSTEM_PROMPT},
+                {"role": "user", "content": user},
+            ]
+        )
+        txt = (resp.choices[0].message.content or "").strip()
+        if txt.startswith("{"):
+            # keep it safe: if JSON fails, fall back later
+            return json.loads(txt)
+    except Exception as e:
+        # print for server logs; don't crash the student UX
+        print("LLM parse failed:", e)
+    return {}
+
+NUM = r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?"
+def _floatish(s):
+    if s is None: return None
+    t = str(s).replace("$","").replace(",","").strip()
+    try: return float(t)
+    except: return None
+
+def which_from_text(t):
+    t=t.lower()
+    if "optimal" in t or "mvp=mic" in t: return "optimal"
+    if "plot" in t or "graph" in t: return "plot"
+    if "table" in t: return "table"
+    if "work" in t or "explain" in t: return "work"
+    if "mvp" in t: return "mvp"
+    if "mic" in t: return "mic"
+    if "profit" in t: return "profit"
+    if "mpp" in t: return "mpp"
+    if "app" in t: return "app"
+    if "stage" in t: return "stage"
+    return None
+
+def regex_parse(user: str):
+    d={}
+    m=re.search(r"(?:Py|output price)\s*=?\s*("+NUM+")",user,re.I); d["Py"]=_floatish(m.group(1)) if m else None
+    m=re.search(r"(?:Px|MIC|input price)\s*=?\s*("+NUM+")",user,re.I); d["Px"]=_floatish(m.group(1)) if m else None
+    m=re.search(r"(?:Other|other cost)\s*=?\s*("+NUM+")",user,re.I); d["Other"]=_floatish(m.group(1)) if m else None
+    m=re.search(r"\bL\s*=\s*("+NUM+")",user,re.I); d["L"]=_floatish(m.group(1)) if m else None
+    m=re.search(r"\bk\s*=\s*("+NUM+")",user,re.I); d["k"]=_floatish(m.group(1)) if m else None
+    m=re.search(r"\bx0\s*=\s*("+NUM+")",user,re.I); d["x0"]=_floatish(m.group(1)) if m else None
+    m=re.search(r"(?:range|from|apply)\s*("+NUM+")\s*(?:to|-)\s*("+NUM+")\s*(?:by|in|step)\s*("+NUM+")",user,re.I)
+    if m:
+        d["x_min"]=_floatish(m.group(1)); d["x_max"]=_floatish(m.group(2)); d["x_step"]=_floatish(m.group(3))
+    m=re.search(r"(?:show\s*work|explain)[^\d]*x\s*=?\s*("+NUM+")",user,re.I)
+    if m: d["last_focus_x"]=_floatish(m.group(1))
+    d["which_action"]=which_from_text(user)
+    return d
+
+def parse(user: str):
+    # LLM first, then regex fallback
+    return llm_parse(user) or regex_parse(user)
+
+# ---------- Blackboard ----------
+def explain_row(h,row):
+    lines=[
+        f"At X = {row['X']:.4g}:",
+        f"  Y = L/(1+exp(-k*(X-x0))) with L={h.get('L')}, k={h.get('k')}, x0={h.get('x0')}",
+        f"  ⇒ Y ≈ {row['Y']:.4g}",
+        f"  APP = Y/X ≈ {row['APP']:.4g}",
+        f"  MPP = dY/dX ≈ {row['MPP']:.4g}"
+    ]
+    if 'MVP' in row: lines.append(f"  MVP = MPP·Py ≈ {row['MVP']:.4g}")
+    if 'MIC' in row: lines.append(f"  MIC = Px ≈ {row['MIC']:.4g}")
+    if 'Profit' in row: lines.append(f"  Profit = Py·Y − Px·X − Other ≈ {row['Profit']:.4g}")
     lines.append(f"  Stage = {row['Stage']}")
-    return "\n".join(lines)
+    return "\\n".join(lines)
+
+# ---------- Orchestrator (app53 style) ----------
+def _ask_with_hud(user_text, hud_state):
+    """
+    Returns 8 outputs:
+    1) student answer
+    2) HUD JSON (pretty)
+    3) changed fields
+    4) teacher debug JSON
+    5) new HUD state (dict)
+    6) Blackboard text
+    7) Table (DataFrame)
+    8) Plot (matplotlib figure or None)
+    """
+    parsed = parse(user_text)
+    new_hud, changed = merge_into_hud(hud_state or DEFAULTS, parsed)
+
+    action = new_hud.get("which_action")
+    if not action:
+        msg = "Jerry → Tell me what to do (e.g., 'make table', 'plot mpp', 'find optimal', 'show work at X=…')."
+        return msg, _pp(new_hud), ", ".join(changed) or "(none)", _pp({"parsed":parsed}), new_hud, "(none)", pd.DataFrame(), None
+
+    miss = missing_for(action, new_hud)
+    if miss:
+        msg = f"Jerry → Not enough data for {action}. Missing: {', '.join(miss)}. Add those and ask again."
+        return msg, _pp(new_hud), ", ".join(changed) or "(none)", _pp({"parsed":parsed, "missing":miss}), new_hud, "(none)", pd.DataFrame(), None
+
+    table = pd.DataFrame(); plot = None; steps = "(none)"; reply = ""
 
-# --------------------
-# Controller
-# --------------------
-def controller(user_text, hud_json):
-    # load/ensure hud
     try:
-        hud = json.loads(hud_json) if hud_json else {}
-    except Exception:
-        hud = {}
-    for k, v in DEFAULTS.items():
-        hud.setdefault(k, v)
-
-    hud, updated, intent, raw = parse(user_text, hud)
-
-    # Decide action
-    reply = ""
-    table = pd.DataFrame()
-    plot = None
-    blackboard = ""
-
-    # Some actions require table
-    need_table = intent in ("table","plot","app","mpp","mvp","mic","profit","stage","optimal")
-    if need_table:
-        try:
-            df = table_from_hud(hud)
-        except Exception as e:
-            reply = f"Jerry → {e} \n\n{HELP}"
-            return reply, json.dumps(hud, indent=2), ", ".join(updated) or "(none)", blackboard, table, plot
-
-    if intent == "help" or intent is None:
-        reply = "Jerry → How can I help?\n\n" + HELP
-
-    elif intent == "table":
-        hud["table_ready"] = True
-        hud["last_table_cols"] = list(df.columns)
-        reply = f"Built table for X from {hud['x_min']} to {hud['x_max']} by {hud['x_step']}."
-        table = df
-        blackboard = sample_work(hud, df)
-
-    elif intent == "plot":
-        # choose what to plot
-        metric = "Y"
-        if re.search(r'mpp', raw, flags=re.I): metric = "MPP"
-        elif re.search(r'app', raw, flags=re.I): metric = "APP"
-        elif re.search(r'mvp', raw, flags=re.I) and "MVP" in df.columns: metric = "MVP"
-        elif re.search(r'profit', raw, flags=re.I) and "Profit" in df.columns: metric = "Profit"
-        fig = plt.figure()
-        ax = fig.add_subplot(111)
-        ax.plot(df["X"], df[metric])
-        ax.set_xlabel("X (fertilizer)")
-        ax.set_ylabel(metric)
-        ax.set_title(f"{metric} vs X")
-        plot = fig
-        table = df
-        reply = f"Plotted {metric} vs X."
-        blackboard = sample_work(hud, df)
-
-    elif intent in ("app","mpp","mvp","mic","profit","stage"):
-        table = df
-        parts = []
-        if intent in ("app","stage"): parts.append("APP")
-        if intent in ("mpp","stage"): parts.append("MPP")
-        if intent in ("mvp","stage") and "MVP" in df.columns: parts.append("MVP")
-        if intent in ("mic","stage") and "MIC" in df.columns: parts.append("MIC")
-        if intent in ("profit","stage") and "Profit" in df.columns: parts.append("Profit")
-        if intent == "stage": parts.append("Stage")
-        show = [c for c in parts if c in df.columns] + ["X"]
-        show = list(dict.fromkeys(["X"] + show))  # ensure X first, unique
-        reply = "Computed metrics. Showing relevant columns."
-        table = df[show]
-        blackboard = sample_work(hud, df)
-        if intent == "mvp" and "MVP" not in df.columns:
-            reply += " (Set Py first)"
-        if intent == "mic" and "MIC" not in df.columns:
-            reply += " (Set Px first)"
-        if intent == "profit" and "Profit" not in df.columns:
-            reply += " (Set Px and Py first)"
-
-    elif intent == "optimal":
-        try:
-            row = find_optimal(hud)
-            reply = (f"Optimal (MVP ≈ MIC in Stage II):\n"
-                     f"X* ≈ {row['X']:.4g}, Y* ≈ {row['Y']:.4g}, "
-                     f"MVP ≈ {row.get('MVP', float('nan')):.4g}, MIC ≈ {row.get('MIC', float('nan')):.4g}")
-            if 'Profit' in row:
-                reply += f", Profit* ≈ {row['Profit']:.4g}"
-            df = table_from_hud(hud)
-            cols = ['X','Y','MPP']
-            if 'MVP' in df.columns: cols.append('MVP')
-            if 'MIC' in df.columns: cols.append('MIC')
-            if 'Profit' in df.columns: cols.append('Profit')
+        if action in ("table","app","mpp","mvp","mic","profit","stage","plot","optimal"):
+            df = build_table(new_hud)
+            table = df
+
+        if action == "table":
+            reply = f"Built table for X from {new_hud['x_min']} to {new_hud['x_max']} by {new_hud['x_step']}."
+            row = df.iloc[len(df)//2].to_dict()
+            steps = explain_row(new_hud, row)
+
+        elif action == "plot":
+            metric = "Y"
+            t = user_text.lower()
+            if "mpp" in t: metric = "MPP"
+            elif "app" in t: metric = "APP"
+            elif "mvp" in t and "MVP" in df.columns: metric = "MVP"
+            elif "profit" in t and "Profit" in df.columns: metric = "Profit"
+            fig = plt.figure()
+            ax = fig.add_subplot(111)
+            ax.plot(df["X"], df[metric])
+            ax.set_xlabel("X (fertilizer)"); ax.set_ylabel(metric); ax.set_title(f"{metric} vs X")
+            plot = fig
+            reply = f"Plotted {metric} vs X."
+            row = df.iloc[len(df)//2].to_dict(); steps = explain_row(new_hud, row)
+
+        elif action in ("app","mpp","mvp","mic","profit","stage"):
+            cols = ["X"]
+            if action in ("app","stage"): cols.append("APP")
+            if action in ("mpp","stage"): cols.append("MPP")
+            if action in ("mvp","stage") and "MVP" in df.columns: cols.append("MVP")
+            if action in ("mic","stage") and "MIC" in df.columns: cols.append("MIC")
+            if action in ("profit","stage") and "Profit" in df.columns: cols.append("Profit")
+            cols.append("Stage")
+            table = df[[c for c in cols if c in df.columns]]
+            reply = "Computed metrics. Showing relevant columns."
+            row = df.iloc[len(df)//2].to_dict(); steps = explain_row(new_hud, row)
+            if action=="mvp" and "MVP" not in df.columns: reply += " (Set Py first)"
+            if action=="mic" and "MIC" not in df.columns: reply += " (Set Px first)"
+            if action=="profit" and "Profit" not in df.columns: reply += " (Set Px and Py first)"
+
+        elif action == "optimal":
+            row_star, df = find_optimal(new_hud)
+            reply = (f"Optimal (MVP ≈ MIC in Stage II): X* ≈ {row_star['X']:.4g}, "
+                     f"Y* ≈ {row_star['Y']:.4g}"
+                     + (f", Profit* ≈ {row_star['Profit']:.4g}" if "Profit" in df.columns else ""))
+            cols = ["X","Y","MPP"]
+            if "MVP" in df.columns: cols.append("MVP")
+            if "MIC" in df.columns: cols.append("MIC")
+            if "Profit" in df.columns: cols.append("Profit")
             table = df[cols]
-            blackboard = sample_work(hud, df) + "\n\nRule: choose X where MVP = MIC (in Stage II)."
-        except Exception as e:
-            reply = f"Jerry → {e} \n(Set Px and Py, and logistic params)."
+            steps = explain_row(new_hud, row_star.to_dict()) + "\\n\\nRule: choose X where MVP = MIC (in Stage II)."
 
-    else:
-        reply = "Okay — updated HUD. Ask me to 'make table', 'plot yield', 'compute MPP', 'profit', 'find optimal', etc."
+        elif action == "work":
+            x = new_hud.get("last_focus_x")
+            if x is None:
+                reply = "Tell me 'show work at X=…' with a value."
+            else:
+                rowdf = row_at_x(new_hud, x)
+                table = rowdf
+                reply = f"Exact work at X={x}."
+                steps = explain_row(new_hud, rowdf.iloc[0].to_dict())
+
+        else:
+            reply = "Okay."
+    except Exception as e:
+        reply = f"Jerry → {e}"
 
-    return reply, json.dumps(hud, indent=2), ", ".join(updated) or "(none)", blackboard, table, plot
+    return reply, _pp(new_hud), ", ".join(changed) or "(none)", _pp({"parsed":parsed}), new_hud, steps, table, plot
+
+# ---------- UI ----------
+with gr.Blocks(css="footer {visibility: hidden}") as demo:
+    gr.Markdown("## Jerry — Logistic Yield Coach (app52) — OpenAI GPT-5.0 parser (app53-style)")
+
+    hud_state = gr.State(copy.deepcopy(DEFAULTS))
 
-with gr.Blocks() as demo:
-    gr.Markdown("### Jerry — MIC/Profit Coach (Logistic Yield, NLP HUD)")
     with gr.Row():
         with gr.Column(scale=1):
-            user = gr.Textbox(label="Talk to Jerry", value="use logistic L=1200, k=0.06, x0=60; set Py=0.5, Px=0.25, other cost=300; range 0 to 150 by 5; make table", lines=4)
-            btn = gr.Button("Ask Jerry", variant="primary")
+            q = gr.Textbox(label="Talk to Jerry", lines=4, placeholder="e.g., Py=0.5, Px=0.25, L=1200, k=0.06, x0=60; range 0 to 150 by 5; make table")
+            ask = gr.Button("Ask Jerry", variant="primary")
         with gr.Column(scale=1):
-            out = gr.Textbox(label="Jerry says", lines=10)
+            out = gr.Textbox(label="Jerry says", lines=8)
     with gr.Row():
         with gr.Column(scale=1):
-            hud = gr.Textbox(label="Student HUD — what Jerry sees (persists)", value=json.dumps(DEFAULTS, indent=2), lines=18)
+            gr.Markdown("### Student HUD — what Jerry sees (top = most likely inputs)")
+            hud_box = gr.Textbox(label="HUD (persists this session)", lines=18, value=_pp(DEFAULTS))
+            changed_box = gr.Textbox(label="Fields updated by last prompt", value="(none)", lines=3)
+            steps_box = gr.Textbox(label="Blackboard — show the work", value="(none)", lines=14)
         with gr.Column(scale=1):
-            changed = gr.Textbox(label="Fields updated by last prompt", value="(none)")
-    black = gr.Textbox(label="Blackboard — show the work", value="(none)", lines=12)
-    table = gr.Dataframe(label="Main Output Table", wrap=True)
-    plot = gr.Plot(label="Figure (on demand)")
+            table = gr.Dataframe(label="Main Output Table", wrap=True)
+            plot = gr.Plot(label="Figure (on demand)")
+
+    def runner(user_text, hud):
+        return _ask_with_hud(user_text, hud)
 
-    btn.click(controller, inputs=[user, hud], outputs=[out, hud, changed, black, table, plot])
+    ask.click(runner, [q, hud_state], [out, hud_box, changed_box, gr.Textbox.update(), hud_state, steps_box, table, plot])
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue().launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT","7860")))