All five systems below threshold. Maintain the streak.
"""
# Map system actions into the four temporal windows based on severity
windows = ["RIGHT NOW", "THIS MORNING", "TODAY", "AVOID"]
active = [s for s in system_scores if s.score > 15]
if not active:
active = system_scores[:3]
# Sort: highest-debt system goes to RIGHT NOW
active.sort(key=lambda s: -s.score)
steps = []
for i, s in enumerate(active[:4]):
window = windows[min(i, 3)]
color = WINDOW_COLORS[window]
steps.append((i + 1, window, s.action_text, color))
is_last = lambda i: i == len(steps) - 1
steps_html = ""
for i, (num, window, action, color) in enumerate(steps):
connector = "" if is_last(i) else ''
steps_html += f"""
{str(num).zfill(2)}
{connector}
{window} · {html.escape(active[i].label)}
{html.escape(action)}
"""
return f"""
Recovery Protocol
{steps_html}
"""
def render_science(system_scores) -> str:
items = []
for s in system_scores:
if s.score > 20 and s.science_fact and s.science_cite:
accent = SYSTEM_ACCENTS.get(s.system, ("var(--text-secondary)",))[0]
items.append((accent, s.science_fact, s.science_cite))
if not items:
return ""
cards = "".join(
f"""
Processed on-device. No biometric data transmitted.
"""
def render_face_scan_placeholder() -> str:
"""Call-to-action placeholder for face scan before the user runs an analysis."""
return f"""
📷
Capture a photo or use your webcam
MediaPipe FaceMesh → 7 features → stress MLP · all on-device
"""
# ─── Debt timeline chart ─────────────────────────────────────────────────
def compute_debt_timeline(system_scores, now=None):
"""Compute how total body debt changes over the recovery window.
Each system decays linearly from its current score to 0 over its
recovery window. Returns list of dicts, each with total score, per-system
breakdown, and the dominant system at that point.
"""
if now is None:
now = datetime.now()
max_window = max((s for s in system_scores), default=None, key=lambda s: s.recovery_hrs)
max_hrs = max_window.recovery_hrs if max_window else 10
max_hrs = max(max_hrs, 8)
max_hrs = min(max_hrs, 48)
system_order = ["cardiovascular", "brain", "liver", "muscular", "gut"]
points = []
for h in range(0, int(max_hrs) + 2, 2):
total = 0
systems_at_h = []
for sys_name in system_order:
s = next((x for x in system_scores if x.system == sys_name), None)
if s is None:
continue
if s.recovery_hrs > 0 and h <= s.recovery_hrs:
remaining_frac = (s.recovery_hrs - h) / s.recovery_hrs
sys_score = round(s.score * remaining_frac, 1)
else:
sys_score = 0.0
total += sys_score
accent = SYSTEM_ACCENTS.get(sys_name, ("var(--text-muted)",))[0]
systems_at_h.append({
"name": sys_name,
"glyph": SYSTEM_GLYPHS.get(sys_name, "•"),
"score": round(sys_score),
"color": accent,
})
total = round(total)
color, _, _ = debt_tier(total)
label = "Now" if h == 0 else f"+{h}h"
# Find dominant system (highest contributing)
dominant = max(systems_at_h, key=lambda x: x["score"]) if systems_at_h else None
points.append({
"hour": h,
"score": total,
"color": color,
"label": label,
"systems": systems_at_h,
"dominant": dominant["name"] if dominant and dominant["score"] > 0 else None,
"dominant_glyph": dominant["glyph"] if dominant and dominant["score"] > 0 else "",
})
return points
def render_timeline(points: list[dict]) -> str:
"""Render the debt timeline as a horizontal bar chart with system breakdown.
Each bar is a stacked segment showing each system's contribution in its
accent color. The dominant system is labeled to the right of the bar.
"""
if not points:
return ""
max_score = max(p["score"] for p in points) or 1
rows = []
for p in points:
now_tag = '· now' if p["hour"] == 0 else ""
# Build stacked bar segments — each system gets a proportional slice
bar_pct = max(2.0, (p["score"] / max_score) * 100)
segments = []
if p["systems"] and p["score"] > 0:
total_sys = sum(x["score"] for x in p["systems"])
for sys in p["systems"]:
if sys["score"] <= 0:
continue
share = (sys["score"] / total_sys) * 100
sys_label = {"cardiovascular":"Cardiovascular","brain":"Brain","liver":"Liver","muscular":"Muscular","gut":"Gut"}.get(sys["name"], sys["name"])
segments.append(f'')
else:
segments = []
seg_html = "".join(segments) if segments else f''
# Dominant system indicator
dom_html = ""
if p["dominant"] and p["dominant_glyph"]:
dom_color = SYSTEM_ACCENTS.get(p["dominant"], ("var(--text-secondary)",))[0]
dom_html = f'{p["dominant_glyph"]}'
rows.append(f"""
{p['label']}{now_tag}
{seg_html}
{p['score']}
{dom_html}
""")
# Build a legend showing system glyphs
legend_items = []
for sys_name in ["cardiovascular", "brain", "liver", "muscular", "gut"]:
accent = SYSTEM_ACCENTS.get(sys_name, ("var(--text-muted)",))[0]
glyph = SYSTEM_GLYPHS.get(sys_name, "•")
label = {
"cardiovascular": "Cardio",
"brain": "Brain",
"liver": "Liver",
"muscular": "Muscle",
"gut": "Gut",
}.get(sys_name, sys_name)
legend_items.append(f'{glyph} {label}')
legend_html = f'
{" ".join(legend_items)}
' if len(legend_items) > 0 else ""
return f"""
Recovery forecast
{legend_html}
{"".join(rows)}
"""
def render_plan(plan: dict | None, lines_so_far: list[str] | None = None) -> str:
"""Triage plan: 3 lines from SmolLM2's structured plan step.
`lines_so_far` lets the UI show the plan being formed (one line at a
time) as the LLM streams. Falls back to `plan` dict for the final
render.
"""
if lines_so_far is None:
lines_so_far = []
if plan:
if plan.get("priority"):
lines_so_far.append(f"PRIORITY: {plan['priority']}")
if plan.get("secondary"):
lines_so_far.append(f"SECONDARY: {plan['secondary']}")
if plan.get("avoid"):
lines_so_far.append(f"AVOID: {plan['avoid']}")
if not lines_so_far and not plan:
return ""
rendered_lines = []
for line in lines_so_far:
up = line.upper().strip()
if up.startswith("PRIORITY:"):
color = "#DC2626"
label = "PRIORITY"
elif up.startswith("SECONDARY:"):
color = "#EA580C"
label = "SECONDARY"
elif up.startswith("AVOID:"):
color = "#A78BFA"
label = "AVOID"
else:
color = "var(--text-muted)"
label = ""
rest = line.split(":", 1)[1].strip() if ":" in line else line
rendered_lines.append(f"""
{label}{html.escape(rest)}
""")
return f"""
Triage plan SmolLM2-360M
{''.join(rendered_lines)}
"""
def render_counterfactual(cf: dict | None) -> str:
if not cf:
return ""
accent = SYSTEM_ACCENTS.get(cf["system"], ("var(--text-secondary)",))[0]
return f"""
WHAT WOULD CHANGE THIS
If you had {html.escape(cf['lever_label'])},
{html.escape(cf['system_label'])} debt would drop
from {cf['from_score']} to
{cf['to_score']}.
"""
def render_agent_trace(steps: list[tuple[str, str, str]]) -> str:
"""steps: list of (label, status, message) where status is pending|active|done|error."""
if steps:
items = []
for label, status, message in steps:
items.append(f"""
"""
# ─── Compare scenarios ───────────────────────────────────────────────────
def _build_compare_label(stressors: list) -> str:
"""Build a short label from stressor icons."""
if not stressors:
return "Clear day"
icons = [STRESSOR_DEFS[s.type]["icon"] for s in stressors]
return " ".join(icons)
def render_comparison_html(comparisons: list) -> str:
"""Render the horizontal comparison carousel as HTML."""
if not comparisons:
return ''
cards = []
for i, c in enumerate(comparisons):
color, verdict, _ = debt_tier(c["score"])
systems_html = ""
for sys in c["system_scores"]:
accent = SYSTEM_ACCENTS.get(sys["system"], ("var(--text-secondary)",))[0]
pct = max(0, min(100, sys["score"]))
systems_html += f"""
{sys['glyph']}
"""
cards.append(f"""
{c['score']}
{html.escape(c['label'])}
{html.escape(c['timestamp'])}
{systems_html}
""")
return f'
{"".join(cards)}
'
def save_compare(
comparisons, # list from gr.State
alcohol, alcohol_type, alcohol_count,
training, training_area, training_intensity,
sleep, sleep_hours,
stress, stress_carried,
ill, ill_severity,
care,
bed_time, wake_time,
):
"""Recompute from current form inputs, append to comparisons, return updated state + HTML."""
stressors = build_stressors(
alcohol, alcohol_type, alcohol_count,
training, training_area, training_intensity,
sleep, sleep_hours, stress, stress_carried,
ill, ill_severity, care,
)
score = compute_live_score(stressors)
system_scores = compute_system_scores(
stressors,
now=datetime.now(),
bed_time=bed_time or None,
wake_time=wake_time or None,
)
label = _build_compare_label(stressors)
now_str = datetime.now().strftime("%I:%M %p").lstrip("0")
entry = {
"score": score,
"label": label,
"timestamp": now_str,
"system_scores": [
{
"system": s.system,
"glyph": SYSTEM_GLYPHS.get(s.system, "•"),
"score": s.score,
}
for s in system_scores
],
}
new_list = list(comparisons or [])
new_list.append(entry)
return new_list, render_comparison_html(new_list)
def remove_compare(comparisons, idx: int):
"""Remove a comparison by index. Returns -1 sentinel to reset the trigger."""
new_list = list(comparisons or [])
if 0 <= idx < len(new_list):
del new_list[idx]
return new_list, render_comparison_html(new_list), -1
def clear_comparisons():
"""Clear all comparisons."""
return [], ""
# ─── Pre-compute sample preview ─────────────────────────────────────────────
SAMPLE_HERO, SAMPLE_PLAN, SAMPLE_METERS, SAMPLE_FACE, SAMPLE_TIMELINE, SAMPLE_RX, SAMPLE_TRACE, SAMPLE_CF, SAMPLE_COACH = render_sample_preview()
# ─── Layout ──────────────────────────────────────────────────────────────────
with gr.Blocks(title="Body Debt") as demo:
gr.HTML(THEME_TOGGLE_HTML)
gr.HTML(f"""
🫀 Body Debt
Quantify your physiological debt. Get a precise, system-level recovery plan. On-device AI. Zero cloud calls.