Update app.py

app.py

@@ -1,24 +1,11 @@
 """
 app.py  —  Second Brain Gradio Application
-==========================================
-Modular structure:
-    core/database.py   — SQLite persistence (users, tasks, life areas, goals, AI context)
-    core/ai_engine.py  — All Groq API calls (task parsing, scheduling, journaling)
-    core/styles.py     — CSS
-
-Run locally:
-    pip install -r requirements.txt
-    GROQ_API_KEY=gsk_... python app.py
-
-HuggingFace Spaces:
-    Add GROQ_API_KEY in Space Settings → Repository Secrets
 """
 
 import os
 import gradio as gr
 from datetime import date, datetime
 
-# ── Core modules ──────────────────────────────────────────────────────────────
 from core.database import (
     init_db, register_user, login_user, get_username,
     create_default_life_areas, save_goals, get_goals,
@@ -33,11 +20,11 @@ from core.ai_engine import (
 )
 from core.styles import CSS
 
-# ── Boot ──────────────────────────────────────────────────────────────────────
 init_db()
-init_groq()                         # reads GROQ_API_KEY from env
+init_groq()
 
 TASK_HEADERS = ["ID", "Done", "Title", "Area", "Urgency", "Importance", "Mind", "Min", "Date"]
+_whisper_model = None
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -51,38 +38,84 @@ def _info(msg): return f'<span style="color:#60a5fa;font-size:13px">ℹ {msg}</s
 def _stat(val, label, color):
     return f'<div class="stat-card"><div class="stat-num" style="color:{color}">{val}</div><div class="stat-label">{label}</div></div>'
 
-def _fmt_tasks(tasks: list) -> list:
-    rows = []
-    for t in tasks:
-        rows.append([
-            t["id"],
-            "✅" if t["is_completed"] else "⬜",
-            ("🔁 " if t["is_habit"] else "") + t["title"],
-            t["life_area"]    or "—",
-            t["urgency"]      or "—",
-            t["importance"]   or "—",
-            t["state_of_mind"] or "—",
-            str(t["time_estimate"]) + "m" if t["time_estimate"] else "—",
-            t["scheduled_date"] or "—",
-        ])
-    return rows
+def _fmt_tasks(tasks):
+    return [[
+        t["id"], "✅" if t["is_completed"] else "⬜",
+        ("🔁 " if t["is_habit"] else "") + t["title"],
+        t["life_area"] or "—", t["urgency"] or "—", t["importance"] or "—",
+        t["state_of_mind"] or "—",
+        str(t["time_estimate"]) + "m" if t["time_estimate"] else "—",
+        t["scheduled_date"] or "—",
+    ] for t in tasks]
 
 def _area_choices(user_id):
-    if not user_id:
-        return ["All"]
-    return ["All"] + get_life_area_names(user_id)
+    return ["All"] + (get_life_area_names(user_id) if user_id else [])
 
 def _ensure_context(user_id):
-    """Load or create blank AI context for a user."""
     ctx = load_user_context(user_id)
     if not ctx:
         ctx = create_blank_context(user_id)
         save_user_context(user_id, ctx)
     return ctx
 
+def _transcribe(audio_path):
+    global _whisper_model
+    from faster_whisper import WhisperModel
+    if _whisper_model is None:
+        _whisper_model = WhisperModel("small", device="cpu", compute_type="int8")
+    segments, _ = _whisper_model.transcribe(audio_path)
+    return " ".join(seg.text for seg in segments).strip()
+
+def _build_clar_html(clarifications):
+    if not clarifications:
+        return ""
+    items = "".join(f"<li style='margin:4px 0'>{q}</li>" for q in clarifications)
+    return (
+        f'<div style="margin:10px 0;padding:12px;background:#0c0f1a;'
+        f'border-left:3px solid #a78bfa;border-radius:8px">'
+        f'<div style="color:#a78bfa;font-size:11px;font-weight:600;margin-bottom:6px">⚠ Please clarify:</div>'
+        f'<ul style="color:#94a3b8;font-size:13px;margin:0;padding-left:16px">{items}</ul></div>'
+    )
+
+def _run_parse(task_text, user_id):
+    ctx   = _ensure_context(user_id)
+    goals = get_goals(user_id)
+    areas = get_life_area_names(user_id) if user_id else []
+    result = parse_task_with_groq(task_text, ctx, goals, areas)
+    clars  = result.get("clarifications_needed", [])
+    area_choices = areas or ["Work","Health","Finance","Learning","Personal","Family","Other"]
+    area_val = result.get("life_area") or area_choices[0]
+    if area_val not in area_choices:
+        area_choices = [area_val] + area_choices
+    return result, _build_clar_html(clars), bool(clars), area_val, clars
+
+def _parse_result_to_outputs(result, clar_html, has_clar, area_val, clars, task_text, status=""):
+    """Convert a parse result into the standard 15-value tuple for UI outputs."""
+    if not status:
+        status = _ok("AI classified your task �� answer the questions above." if has_clar else "AI classified your task ✓")
+    return (
+        gr.update(visible=True),
+        result.get("title", task_text),
+        clar_html, area_val,
+        result.get("urgency", "Not Urgent"),
+        result.get("importance", "Important"),
+        result.get("state_of_mind", "Easy"),
+        int(result.get("time_estimate") or 30),
+        str(date.today()), False, "Daily",
+        status,
+        gr.update(visible=has_clar),
+        clars, task_text,
+    )
+
+_EMPTY_PARSE = (
+    gr.update(visible=False), "", "", "Work", "Not Urgent", "Important",
+    "Easy", 30, str(date.today()), False, "Daily", "",
+    gr.update(visible=False), [], "",
+)
+
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# AUTH HANDLERS
+# AUTH
 # ═══════════════════════════════════════════════════════════════════════════════
 
 def handle_login(username, password):
@@ -90,9 +123,7 @@ def handle_login(username, password):
     if not uid:
         return None, "", _err(msg), gr.update(visible=True), gr.update(visible=False)
     spawn_due_habits(uid)
-    uname = get_username(uid)
-    return uid, uname, _ok(msg), gr.update(visible=False), gr.update(visible=True)
-
+    return uid, get_username(uid), _ok(msg), gr.update(visible=False), gr.update(visible=True)
 
 def handle_register(username, password, wake, sleep, focus, goals_text):
     uid, msg = register_user(username, password)
@@ -101,20 +132,17 @@ def handle_register(username, password, wake, sleep, focus, goals_text):
     create_default_life_areas(uid)
     if goals_text.strip():
         save_goals(uid, goals_text)
-    prefs = {"wake_time": wake or "07:30", "sleep_time": sleep or "23:00", "focus_peak": focus or "Morning"}
-    ctx = create_blank_context(uid, prefs)
+    ctx = create_blank_context(uid, {"wake_time": wake or "07:30", "sleep_time": sleep or "23:00", "focus_peak": focus or "Morning"})
     save_user_context(uid, ctx)
     spawn_due_habits(uid)
-    uname = get_username(uid)
-    return uid, uname, _ok(msg + " Logged in!"), gr.update(visible=False), gr.update(visible=True)
-
+    return uid, get_username(uid), _ok(msg + " Logged in!"), gr.update(visible=False), gr.update(visible=True)
 
 def handle_logout(user_id):
     return None, "", gr.update(visible=True), gr.update(visible=False)
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# TODAY TAB HANDLERS
+# TODAY TAB
 # ═══════════════════════════════════════════════════════════════════════════════
 
 def refresh_today(user_id):
@@ -123,694 +151,527 @@ def refresh_today(user_id):
     tasks = get_tasks(user_id, only_today=True)
     s = get_today_stats(user_id)
     c = "#4ade80" if s["remaining"] == 0 and s["total"] > 0 else "#f87171"
-    return (
-        _fmt_tasks(tasks),
-        _stat(s["total"],     "Today",  "#a78bfa"),
-        _stat(s["done"],      "Done",   "#4ade80"),
-        _stat(s["remaining"], "Left",   c),
-    )
-
-
-def show_text_panel():
-    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
-
-def show_voice_panel():
-    return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
-
-def show_plan_panel():
-    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+    return _fmt_tasks(tasks), _stat(s["total"],"Today","#a78bfa"), _stat(s["done"],"Done","#4ade80"), _stat(s["remaining"],"Left",c)
 
-def hide_panels():
-    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+def show_text_panel():  return gr.update(visible=True),  gr.update(visible=False), gr.update(visible=False)
+def show_voice_panel(): return gr.update(visible=False), gr.update(visible=True),  gr.update(visible=False)
+def show_plan_panel():  return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+def hide_panels():      return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
 
+# ── Text parse ─────────────────────────────────────────────────────────────────
 
 def handle_parse_text(task_text, user_id):
-    """Call Groq to classify a typed task, return pre-filled fields."""
     if not task_text.strip():
-        return (gr.update(visible=False),
-                "", "", "Work", "Not Urgent", "Important", "Easy", 30, str(date.today()), False, "Daily", "",
-                gr.update(visible=False), [], "")
-
-    ctx   = _ensure_context(user_id)
-    goals = get_goals(user_id)
-    areas = get_life_area_names(user_id) if user_id else []
-
-    result = parse_task_with_groq(task_text, ctx, goals, areas)
-
-    clarifications = result.get("clarifications_needed", [])
-    clar_html = ""
-    has_clarifications = bool(clarifications)
-    if clarifications:
-        items = "".join(f"<li style='margin:4px 0'>{q}</li>" for q in clarifications)
-        clar_html = (
-            f'<div style="margin:10px 0;padding:12px;background:#0c0f1a;'
-            f'border-left:3px solid #a78bfa;border-radius:8px">'
-            f'<div style="color:#a78bfa;font-size:11px;font-weight:600;margin-bottom:6px">⚠ Please clarify:</div>'
-            f'<ul style="color:#94a3b8;font-size:13px;margin:0;padding-left:16px">{items}</ul></div>'
-        )
-
-    area_choices = areas if areas else ["Work", "Health", "Finance", "Learning", "Personal", "Family", "Other"]
-    area_val     = result.get("life_area") or (area_choices[0] if area_choices else "Work")
-    if area_val not in area_choices:
-        area_choices = [area_val] + area_choices
-
-    return (
-        gr.update(visible=True),
-        result.get("title", task_text),
-        clar_html,
-        area_val,
-        result.get("urgency", "Not Urgent"),
-        result.get("importance", "Important"),
-        result.get("state_of_mind", "Easy"),
-        int(result.get("time_estimate") or 30),
-        str(date.today()),
-        False,
-        "Daily",
-        _ok("AI classified your task — please answer the clarification questions above." if has_clarifications else "AI classified your task"),
-        gr.update(visible=has_clarifications),  # clar_reply_row
-        clarifications,                          # clar_questions_state
-        task_text,                               # original_task_state
-    )
-
+        return _EMPTY_PARSE
+    return _parse_result_to_outputs(*_run_parse(task_text, user_id), task_text)
 
 def handle_clarification_reply(user_reply, original_task, clarifications, user_id):
-    """Re-run Groq classification with the original task + clarification Q&A appended."""
     if not user_reply.strip():
-        return (gr.update(), gr.update(), gr.update(), gr.update(),
-                gr.update(), gr.update(), gr.update(), gr.update(visible=True), "")
-
-    ctx   = _ensure_context(user_id)
-    goals = get_goals(user_id)
-    areas = get_life_area_names(user_id) if user_id else []
-
-    # Build enriched task description: original + each clarification + the user's answer
-    q_block = "\n".join(f"Q: {q}" for q in clarifications)
-    enriched = (
-        f"{original_task}\n\n"
-        f"Additional context from user (answers to clarification questions):\n"
-        f"{q_block}\n"
-        f"A: {user_reply}"
-    )
-
-    result = parse_task_with_groq(enriched, ctx, goals, areas)
-
-    # If AI still has clarifications, show them; otherwise hide the clarification row
-    remaining = result.get("clarifications_needed", [])
-    if remaining:
-        items = "".join(f"<li style='margin:4px 0'>{q}</li>" for q in remaining)
-        clar_html_val = (
-            f'<div style="margin:10px 0;padding:12px;background:#0c0f1a;'
-            f'border-left:3px solid #a78bfa;border-radius:8px">'
-            f'<div style="color:#a78bfa;font-size:11px;font-weight:600;margin-bottom:6px">⚠ Please clarify:</div>'
-            f'<ul style="color:#94a3b8;font-size:13px;margin:0;padding-left:16px">{items}</ul></div>'
-        )
-        clar_row_visible = True
-    else:
-        clar_html_val    = '<span style="color:#4ade80;font-size:13px">✓ Clarified — classification updated!</span>'
-        clar_row_visible = False
-
-    area_choices = areas if areas else ["Work","Health","Finance","Learning","Personal","Family","Other"]
-    area_val     = result.get("life_area") or (area_choices[0] if area_choices else "Work")
-
+        return (gr.update(),)*7 + (gr.update(visible=True), [])
+    q_block  = "\n".join(f"Q: {q}" for q in clarifications)
+    enriched = f"{original_task}\n\nUser clarification:\n{q_block}\nA: {user_reply}"
+    result, clar_html_val, still_has, area_val, remaining = _run_parse(enriched, user_id)
+    if not still_has:
+        clar_html_val = '<span style="color:#4ade80;font-size:13px">✓ Classification updated!</span>'
     return (
-        result.get("title", original_task),
-        clar_html_val,
-        area_val,
-        result.get("urgency", "Not Urgent"),
-        result.get("importance", "Important"),
-        result.get("state_of_mind", "Easy"),
-        int(result.get("time_estimate") or 30),
-        gr.update(visible=clar_row_visible),
-        remaining,
+        result.get("title", original_task), clar_html_val, area_val,
+        result.get("urgency","Not Urgent"), result.get("importance","Important"),
+        result.get("state_of_mind","Easy"), int(result.get("time_estimate") or 30),
+        gr.update(visible=still_has), remaining,
     )
 
+def handle_clar_voice(audio_path, original_task, clarifications, user_id):
+    if not audio_path:
+        return (gr.update(),)*7 + (gr.update(visible=True), [])
+    try:
+        reply = _transcribe(audio_path)
+        return handle_clarification_reply(reply, original_task, clarifications, user_id)
+    except Exception as e:
+        return (gr.update(),)*7 + (gr.update(visible=True), clarifications)
 
-def handle_transcribe_voice(audio_path, user_id):
-    """Whisper transcription then Groq parse — same pipeline as notebook."""
+# ── Voice parse — full pipeline ────────────────────────────────────────────────
+
+def handle_voice_parse(audio_path, user_id):
     if audio_path is None:
-        return gr.update(visible=False), _err("No audio recorded.")
+        return _EMPTY_PARSE[:-2] + (_err("No audio recorded."), gr.update(visible=False), [], "")
     try:
-        from faster_whisper import WhisperModel
-        global _whisper_model
-        if _whisper_model is None:
-            _whisper_model = WhisperModel("small", device="cpu", compute_type="int8")
-        segments, _ = _whisper_model.transcribe(audio_path)
-        text = " ".join(seg.text for seg in segments).strip()
-        return gr.update(visible=True, value=text), _ok(f'Transcribed: "{text[:60]}..."')
+        text = _transcribe(audio_path)
     except Exception as e:
-        return gr.update(visible=False), _err(f"Transcription error: {e}")
+        return _EMPTY_PARSE[:-2] + (_err(f"Transcription error: {e}"), gr.update(visible=False), [], "")
+    if not text:
+        return _EMPTY_PARSE[:-2] + (_err("Could not hear anything. Try again."), gr.update(visible=False), [], "")
+    result, clar_html, has_clar, area_val, clars = _run_parse(text, user_id)
+    preview = text[:50] + ("…" if len(text) > 50 else "")
+    status  = _ok(f'Heard: "{preview}" — classified ✓' + (" Please answer questions." if has_clar else ""))
+    return _parse_result_to_outputs(result, clar_html, has_clar, area_val, clars, text, status)
 
-_whisper_model = None
+# ── Confirm task ───────────────────────────────────────────────────────────────
 
-
-def handle_confirm_task(user_id, title, area, urgency, importance, state,
-                        time_est, sched_date, is_habit, habit_interval):
+def handle_confirm_task(user_id, title, area, urgency, importance, state, time_est, sched_date, is_habit, habit_interval):
     if not user_id:
         return _err("Not logged in."), [], _stat("—","Today","#a78bfa"), _stat("—","Done","#4ade80"), _stat("—","Left","#f87171"), gr.update(visible=False)
     if not title.strip():
         return _err("Title cannot be empty."), [], _stat("—","Today","#a78bfa"), _stat("—","Done","#4ade80"), _stat("—","Left","#f87171"), gr.update(visible=True)
-
-    task = {
-        "title": title, "life_area": area,
-        "urgency": urgency, "importance": importance, "state_of_mind": state,
-        "time_estimate": int(time_est or 30),
-        "is_habit": is_habit,
-        "habit_interval": habit_interval if is_habit else "",
-    }
-    save_task(user_id, task, sched_date)
+    save_task(user_id, {
+        "title": title, "life_area": area, "urgency": urgency, "importance": importance,
+        "state_of_mind": state, "time_estimate": int(time_est or 30),
+        "is_habit": is_habit, "habit_interval": habit_interval if is_habit else "",
+    }, sched_date)
     rows, s1, s2, s3 = refresh_today(user_id)
     return _ok("Task saved!"), rows, s1, s2, s3, gr.update(visible=False)
 
-
 def handle_generate_schedule(user_id, prompt):
-    if not user_id:
-        return _err("Not logged in.")
+    if not user_id: return _err("Not logged in.")
     tasks = get_tasks(user_id, only_today=True, include_completed=False)
-    if not tasks:
-        return _err("No incomplete tasks today to schedule.")
-
-    ctx   = _ensure_context(user_id)
-    goals = get_goals(user_id)
-    sched = generate_schedule(ctx, tasks, prompt or "Schedule my day sensibly.", goals)
-
+    if not tasks: return _err("No incomplete tasks today to schedule.")
+    sched = generate_schedule(_ensure_context(user_id), tasks, prompt or "Schedule my day sensibly.", get_goals(user_id))
     if "error" in sched and "scheduled_tasks" not in sched:
         return _err(f"Scheduling failed: {sched.get('error')}")
-
-    COLOR = {"Flow": "#0ea5e9", "Easy": "#4ade80", "Quick": "#a78bfa", "Personal": "#f87171"}
-    html  = (
-        f'<div style="margin-bottom:14px">'
-        f'<span style="color:#a78bfa;font-size:12px;font-weight:600">📅 {sched.get("schedule_date","Today")}</span>'
-        f'<p style="color:#475569;font-size:13px;margin:6px 0 0">{sched.get("day_summary","")}</p>'
-        f'</div>'
-    )
-
+    COLOR = {"Flow":"#0ea5e9","Easy":"#4ade80","Quick":"#a78bfa","Personal":"#f87171"}
+    html  = (f'<div style="margin-bottom:14px"><span style="color:#a78bfa;font-size:12px;font-weight:600">📅 {sched.get("schedule_date","Today")}</span>'
+             f'<p style="color:#475569;font-size:13px;margin:6px 0 0">{sched.get("day_summary","")}</p></div>')
     for t in sched.get("scheduled_tasks", []):
-        sm = t.get("state_of_mind", "Easy")
-        c  = COLOR.get(sm, "#6366f1")
-        html += (
-            f'<div class="sched-card" style="border-left-color:{c}">'
-            f'<div class="sched-time">{t.get("start_time")} – {t.get("end_time")}</div>'
-            f'<div class="sched-title">{t.get("title")}</div>'
-            f'<div class="sched-meta">{t.get("life_area","—")} · {sm} · {t.get("duration_minutes")}min</div>'
-            f'<div class="sched-why">{t.get("scheduling_reason","")}</div>'
-            f'</div>'
-        )
-
+        sm = t.get("state_of_mind","Easy"); c = COLOR.get(sm,"#6366f1")
+        html += (f'<div class="sched-card" style="border-left-color:{c}"><div class="sched-time">{t.get("start_time")} – {t.get("end_time")}</div>'
+                 f'<div class="sched-title">{t.get("title")}</div><div class="sched-meta">{t.get("life_area","—")} · {sm} · {t.get("duration_minutes")}min</div>'
+                 f'<div class="sched-why">{t.get("scheduling_reason","")}</div></div>')
     if sched.get("deferred_tasks"):
-        html += '<div style="margin-top:12px;color:#334155;font-size:11px;font-weight:600;letter-spacing:.6px;text-transform:uppercase">Deferred</div>'
+        html += '<div style="margin-top:12px;color:#334155;font-size:11px;font-weight:600;text-transform:uppercase">Deferred</div>'
         for t in sched["deferred_tasks"]:
             html += f'<div style="color:#475569;font-size:12px;padding:3px 0">✗ {t["title"]} — {t.get("reason","")}</div>'
-
     for w in sched.get("warnings", []):
         html += f'<div style="margin-top:8px;color:#f59e0b;font-size:12px">⚠ {w}</div>'
-
     return html
 
-
 def handle_toggle_today(task_id, user_id):
-    if task_id and user_id:
-        toggle_task_complete(int(task_id), user_id)
+    if task_id and user_id: toggle_task_complete(int(task_id), user_id)
     rows, s1, s2, s3 = refresh_today(user_id)
     return rows, s1, s2, s3, _ok("Updated")
 
-
 def handle_delete_today(task_id, user_id):
-    if task_id and user_id:
-        delete_task(int(task_id), user_id)
+    if task_id and user_id: delete_task(int(task_id), user_id)
     rows, s1, s2, s3 = refresh_today(user_id)
     return rows, s1, s2, s3, _ok("Deleted")
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# ALL TASKS TAB HANDLERS
+# ALL TASKS TAB
 # ═══════════════════════════════════════════════════════════════════════════════
 
 def refresh_all_tasks(user_id, filter_area="All", only_today=False):
-    if not user_id:
-        return []
-    return _fmt_tasks(get_tasks(user_id, filter_area=filter_area, only_today=only_today))
-
+    return _fmt_tasks(get_tasks(user_id, filter_area=filter_area, only_today=only_today)) if user_id else []
 
 def handle_toggle_all(task_id, user_id, filter_area, only_today):
-    if task_id and user_id:
-        toggle_task_complete(int(task_id), user_id)
+    if task_id and user_id: toggle_task_complete(int(task_id), user_id)
     return refresh_all_tasks(user_id, filter_area, only_today), _ok("Updated")
 
-
 def handle_delete_all(task_id, user_id, filter_area, only_today):
-    if task_id and user_id:
-        delete_task(int(task_id), user_id)
+    if task_id and user_id: delete_task(int(task_id), user_id)
     return refresh_all_tasks(user_id, filter_area, only_today), _ok("Deleted")
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# JOURNAL TAB HANDLERS
+# JOURNAL — CHAT-FIRST, VOICE-AWARE
 # ═══════════════════════════════════════════════════════════════════════════════
 
-def handle_load_journal_tasks(user_id):
+def _task_list_md(tasks):
+    if not tasks: return "*No tasks found.*"
+    lines = []
+    for t in tasks:
+        tid    = t.get("task_id") or t.get("id")
+        status = "✅" if (t.get("is_completed") or t.get("completed")) else "⬜"
+        dur    = f" · {t['actual_duration']}m actual" if t.get("actual_duration") else ""
+        lines.append(f"{status} **#{tid}** {t['title']} _{t.get('life_area','')} · {t.get('time_estimate','')}m{dur}_")
+    return "\n".join(lines)
+
+def _parse_ids(text, valid_ids):
+    import re
+    return [int(n) for n in re.findall(r'\b(\d+)\b', text) if int(n) in valid_ids]
+
+def handle_start_journal(user_id):
+    blank = ([], [], False, gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), [], "marking", "")
     if not user_id:
-        return "<p style='color:#f87171'>Not logged in.</p>", gr.update(visible=False), []
-
+        return ([{"role":"assistant","content":"⚠ Please sign in first."}],) + blank[1:]
     tasks = get_tasks(user_id, only_today=True)
     if not tasks:
-        return "<p style='color:#475569;font-size:13px'>No tasks for today.</p>", gr.update(visible=False), []
-
-    rows = ""
-    state = []
-    for t in tasks:
-        status  = "✅" if t["is_completed"] else "⬜"
-        actual  = f" ({t['actual_duration']}m actual)" if t["actual_duration"] else ""
-        rows += (
-            f'<div style="display:flex;align-items:center;gap:10px;padding:8px 0;border-bottom:1px solid #1e293b">'
-            f'<span style="font-family:JetBrains Mono,monospace;color:#334155;font-size:11px;min-width:30px">#{t["id"]}</span>'
-            f'<span style="font-size:16px">{status}</span>'
-            f'<span style="flex:1;font-size:13px;color:#cbd5e1">{t["title"]}</span>'
-            f'<span style="font-size:11px;color:#475569">{t["life_area"] or "—"}</span>'
-            f'<span style="font-size:11px;color:#334155">{t["time_estimate"]}m{actual}</span>'
-            f'</div>'
-        )
-        state.append({
-            "task_id": t["id"], "title": t["title"],
-            "state_of_mind": t["state_of_mind"],
-            "start_time": "", "end_time": "",
-            "time_estimate": t["time_estimate"],
-            "completed": bool(t["is_completed"]),
-            "actual_duration": t["actual_duration"],
-        })
-
-    return f'<div style="font-size:12px">{rows}</div>', gr.update(visible=True), state
-
-
-def handle_journal_mark(task_id, actual_mins, user_id, tasks_state, mark_done: bool):
-    if not task_id or not user_id:
-        return tasks_state, _err("Enter a task ID.")
-    tid = int(task_id)
-    if mark_done:
-        toggle_task_complete(tid, user_id, int(actual_mins) if actual_mins else None)
+        msg = "You don't have any tasks logged for today. Add some tasks first, then come back to reflect!"
+        return ([{"role":"assistant","content":msg}],) + blank[1:]
+
+    tasks_state = [{
+        "task_id": t["id"], "title": t["title"], "life_area": t.get("life_area",""),
+        "state_of_mind": t.get("state_of_mind",""), "time_estimate": t.get("time_estimate",30),
+        "completed": bool(t["is_completed"]), "actual_duration": t.get("actual_duration"),
+    } for t in tasks]
+
+    total     = len(tasks_state)
+    completed = sum(1 for t in tasks_state if t["completed"])
+    task_md   = _task_list_md(tasks_state)
+
+    if completed == total and total > 0:
+        opener = f"🎉 You knocked out all **{total}** tasks today — great work!\n\n{task_md}\n\nDid the day feel productive, or were you grinding through it?"
+    elif completed == 0:
+        opener = (f"Here's what was on your plate today:\n\n{task_md}\n\n"
+                  f"None are marked complete yet. Tell me which ones you finished "
+                  f"(e.g. *\"I did #1 and #3\"*), or say **skip** to go straight to reflecting.")
     else:
-        toggle_task_complete(tid, user_id)
-    for t in tasks_state:
-        if t["task_id"] == tid:
-            t["completed"] = mark_done
-            if mark_done and actual_mins:
-                t["actual_duration"] = int(actual_mins)
-    return tasks_state, _ok("Marked ✅" if mark_done else "Unmarked")
-
-
-def handle_start_journal(user_id, tasks_state):
-    if not user_id:
-        return [], [], False, gr.update(interactive=False), gr.update(interactive=False), _err("Not logged in.")
-    if not tasks_state:
-        return [], [], False, gr.update(interactive=False), gr.update(interactive=False), _err("Load today's tasks first.")
-
-    ctx     = _ensure_context(user_id)
-    opening = build_opening_question(ctx, tasks_state)
-    chat    = [(None, opening["question"])]
-    hist    = [{"role": "assistant", "content": opening["question"], "focus": opening["question_focus"]}]
-
+        incomplete = [t for t in tasks_state if not t["completed"]]
+        inc_str    = ", ".join(f"#{t['task_id']}" for t in incomplete[:4])
+        opener = (f"Here's today's list:\n\n{task_md}\n\n"
+                  f"You've done **{completed}/{total}** so far. Still open: {inc_str}. "
+                  f"Tell me if you finished any more, or say **skip** to reflect.")
+
+    first_msg = {"role": "assistant", "content": opener}
+    hist = [{"role": "assistant", "content": opener, "focus": "task_review"}]
     return (
-        chat, hist, True,
-        gr.update(interactive=True),
-        gr.update(interactive=True),
-        _ok("Session started — type your answer below"),
-    )
-
-
-def handle_send_answer(user_id, answer, chat, hist, tasks_state, active):
-    if not active or not answer.strip():
-        return chat, hist, "", ""
-
-    chat = list(chat) + [(answer, None)]
-    hist = list(hist) + [{"role": "user", "content": answer}]
-
-    ctx    = _ensure_context(user_id)
-    result = get_next_journal_question(ctx, tasks_state, hist)
-
-    if result.get("session_complete"):
-        chat[-1] = (answer, "✅ That's enough for today. Click **Finish & Save** to update your profile.")
-        return chat, hist, "", _ok("Session complete — save when ready")
-
-    next_q = result.get("question", "")
-    hist.append({"role": "assistant", "content": next_q, "focus": result.get("question_focus", "")})
-    chat[-1] = (answer, next_q)
-    return chat, hist, "", ""
+        [first_msg], hist, True,
+        gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True),
+        tasks_state, "marking", "",
+    )
+
+
+def handle_journal_message(user_id, user_text, audio_path, chat, hist, tasks_state, active, phase):
+    """Unified handler for text + voice journal messages."""
+    # Resolve voice input
+    voice_used = False
+    if audio_path is not None:
+        try:
+            transcribed = _transcribe(audio_path)
+            if transcribed:
+                user_text  = transcribed
+                voice_used = True
+        except Exception as e:
+            err = {"role": "assistant", "content": f"⚠ Couldn't transcribe audio: {e}. Please type instead."}
+            return list(chat) + [err], hist, "", None, tasks_state, active, phase, ""
+
+    if not active or not user_text.strip():
+        return chat, hist, "", None, tasks_state, active, phase, ""
+
+    # Show voice transcription as label if voice was used
+    display_text = f"🎙 *{user_text}*" if voice_used else user_text
+    user_msg = {"role": "user", "content": display_text}
+    chat = list(chat) + [user_msg]
+    hist = list(hist) + [{"role": "user", "content": user_text}]
+
+    # ── Phase: marking ────────────────────────────────────────────────────────
+    if phase == "marking":
+        valid_ids = {t["task_id"] for t in tasks_state}
+        mentioned = _parse_ids(user_text, valid_ids)
+        updated   = []
+        for t in tasks_state:
+            if t["task_id"] in mentioned and not t["completed"]:
+                toggle_task_complete(t["task_id"], user_id)
+                t["completed"] = True
+                updated.append(t["title"])
+
+        confirm     = (f"Got it — marked **{', '.join(updated)}** as complete ✅\n\n" if updated else "")
+        skip_words  = {"done","skip","reflect","none","nothing","no more","that's it","let's go","start","go","next","continue"}
+        wants_skip  = any(w in user_text.lower() for w in skip_words)
+        total       = len(tasks_state)
+        done_count  = sum(1 for t in tasks_state if t["completed"])
+
+        if wants_skip or done_count == total or (updated and done_count > 0):
+            # Move to reflection
+            ctx     = _ensure_context(user_id)
+            opening = build_opening_question(ctx, tasks_state)
+            bridge  = confirm + opening["question"]
+            ai_msg  = {"role": "assistant", "content": bridge}
+            hist.append({"role": "assistant", "content": bridge, "focus": opening["question_focus"]})
+            return chat + [ai_msg], hist, "", None, tasks_state, active, "reflecting", ""
+        else:
+            remaining  = [t for t in tasks_state if not t["completed"]]
+            rem_str    = " | ".join(f"#{t['task_id']} {t['title']}" for t in remaining[:5])
+            follow     = confirm + f"Still pending: {rem_str}\n\nAnything else you finished? Or say **skip** to start reflecting."
+            ai_msg     = {"role": "assistant", "content": follow}
+            hist.append({"role": "assistant", "content": follow, "focus": "task_marking"})
+            return chat + [ai_msg], hist, "", None, tasks_state, active, "marking", ""
+
+    # ── Phase: reflecting ─────────────────────────────────────────────────────
+    if phase == "reflecting":
+        try:
+            ctx    = _ensure_context(user_id)
+            result = get_next_journal_question(ctx, tasks_state, hist)
+        except Exception as e:
+            err_msg = {"role": "assistant", "content": f"⚠ AI error: {e}. Try sending again."}
+            return chat + [err_msg], hist, "", None, tasks_state, active, phase, ""
+
+        if result.get("session_complete"):
+            closing = "That's a solid reflection — you've given me plenty to work with. 🧠 Hit **Finish & Save** to lock in your insights!"
+            ai_msg  = {"role": "assistant", "content": closing}
+            hist.append({"role": "assistant", "content": closing, "focus": "complete"})
+            return chat + [ai_msg], hist, "", None, tasks_state, active, "done", _ok("Session complete — click Finish & Save")
+
+        next_q = result.get("question") or "Anything else you'd like to add about today?"
+        ai_msg = {"role": "assistant", "content": next_q}
+        hist.append({"role": "assistant", "content": next_q, "focus": result.get("question_focus","")})
+        return chat + [ai_msg], hist, "", None, tasks_state, active, "reflecting", ""
+
+    # ── Phase: done ───────────────────────────────────────────────────────────
+    nudge = {"role": "assistant", "content": "Session is complete! Click **Finish & Save** to save your insights."}
+    return chat + [nudge], hist, "", None, tasks_state, active, "done", ""
 
 
 def handle_finish_journal(user_id, chat, hist, tasks_state):
     if not user_id or not hist:
-        return chat, _err("Nothing to save.")
-
-    ctx     = _ensure_context(user_id)
-    updated = synthesize_journal(ctx, tasks_state, hist)
-    save_user_context(user_id, updated)
-
-    total = len(tasks_state)
-    done  = sum(1 for t in tasks_state if t.get("completed"))
-    rate  = round(done / total * 100) if total else 0
-    notes = updated.get("learned_patterns", {}).get("notes", [])
-    note_html = "".join(f"<li style='margin:3px 0'>{n}</li>" for n in notes[-3:]) if notes else "<li>No new patterns yet</li>"
+        return list(chat) + [{"role":"assistant","content":"⚠ Nothing to save yet."}], ""
+    try:
+        ctx     = _ensure_context(user_id)
+        updated = synthesize_journal(ctx, tasks_state, hist)
+        save_user_context(user_id, updated)
+    except Exception as e:
+        return list(chat) + [{"role":"assistant","content":f"⚠ Save failed: {e}"}], _err("Save failed")
 
-    return (
-        chat,
-        _ok(f"Insights saved! {done}/{total} tasks ({rate}%) completed.")
-        + f'<ul style="color:#94a3b8;font-size:12px;margin-top:6px;padding-left:16px">{note_html}</ul>'
+    total  = len(tasks_state)
+    done   = sum(1 for t in tasks_state if t.get("completed"))
+    rate   = round(done / total * 100) if total else 0
+    notes  = updated.get("learned_patterns",{}).get("notes",[])
+    notes_md = "\n".join(f"• {n}" for n in notes[-3:]) if notes else "• Keep reflecting to build patterns"
+    summary = (
+        f"✅ **Insights saved!** {done}/{total} tasks ({rate}%) complete today.\n\n"
+        f"**What I learned:**\n{notes_md}\n\n"
+        f"I'll use this to make tomorrow's schedule smarter. Great work today! 🌙"
     )
+    return list(chat) + [{"role":"assistant","content":summary}], _ok(f"Saved! {done}/{total} tasks ({rate}%)")
 
 
 def handle_restart_journal():
-    return [], [], False, gr.update(interactive=False), gr.update(interactive=False), ""
+    return [], [], False, gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), [], "marking", ""
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# LIFE AREAS & GOALS HANDLERS
+# AREAS & GOALS
 # ═══════════════════════════════════════════════════════════════════════════════
 
 def render_areas(user_id):
-    if not user_id:
-        return "", [], []
-    areas  = get_life_areas(user_id)
-    chips  = ""
-    for a in areas:
-        chips += (
-            f'<span class="chip" '
-            f'style="background:{a["color"]}22;color:{a["color"]};border:1px solid {a["color"]}44">'
-            f'{a["name"]}</span> '
-        )
-    html   = f'<div style="margin:4px 0">{chips}</div>' if chips else '<p style="color:#334155;font-size:13px">No areas yet.</p>'
-    names  = [a["name"] for a in areas]
+    if not user_id: return "", [], []
+    areas = get_life_areas(user_id)
+    chips = "".join(
+        f'<span class="chip" style="background:{a["color"]}22;color:{a["color"]};border:1px solid {a["color"]}44">{a["name"]}</span> '
+        for a in areas
+    )
+    html  = f'<div style="margin:4px 0">{chips}</div>' if chips else '<p style="color:#334155;font-size:13px">No areas yet.</p>'
+    names = [a["name"] for a in areas]
     return html, names, names
 
-
 def handle_add_area(user_id, name, color):
     ok, msg = add_life_area(user_id, name, color)
-    css = "ok" if ok else "err"
     html, names, _ = render_areas(user_id)
-    return (
-        f'<span style="color:{"#4ade80" if ok else "#f87171"};font-size:13px">{msg}</span>',
-        html, gr.update(choices=names, value=None), gr.update(value=""),
-    )
-
+    color_txt = "#4ade80" if ok else "#f87171"
+    return f'<span style="color:{color_txt};font-size:13px">{msg}</span>', html, gr.update(choices=names, value=None), gr.update(value="")
 
 def handle_del_area(user_id, name):
-    if not name:
-        return _err("Select an area first."), "", []
+    if not name: return _err("Select an area first."), "", []
     ok, msg = delete_life_area(user_id, name)
     html, names, _ = render_areas(user_id)
-    return (
-        f'<span style="color:{"#4ade80" if ok else "#f87171"};font-size:13px">{msg}</span>',
-        html, gr.update(choices=names, value=None),
-    )
-
+    color_txt = "#4ade80" if ok else "#f87171"
+    return f'<span style="color:{color_txt};font-size:13px">{msg}</span>', html, gr.update(choices=names, value=None)
 
 def handle_save_goals(user_id, goals_text):
-    if not user_id:
-        return _err("Not logged in.")
+    if not user_id: return _err("Not logged in.")
     save_goals(user_id, goals_text)
     return _ok("Goals saved!")
 
-
 def load_goals_txt(user_id):
-    if not user_id:
-        return ""
-    return "\n".join(get_goals(user_id))
+    return "\n".join(get_goals(user_id)) if user_id else ""
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# PREFERENCES HANDLERS
+# PREFERENCES
 # ═══════════════════════════════════════════════════════════════════════════════
 
 def load_prefs(user_id):
     ctx = load_user_context(user_id) if user_id else None
-    if not ctx:
-        return "07:30", "23:00", "Morning", 10, 90
-    p = ctx.get("preferences", {})
-    return (
-        p.get("wake_time", "07:30"),
-        p.get("sleep_time", "23:00"),
-        p.get("focus_peak", "Morning"),
-        p.get("break_duration_minutes", 10),
-        p.get("max_flow_block_minutes", 90),
-    )
-
+    if not ctx: return "07:30","23:00","Morning",10,90
+    p = ctx.get("preferences",{})
+    return p.get("wake_time","07:30"), p.get("sleep_time","23:00"), p.get("focus_peak","Morning"), p.get("break_duration_minutes",10), p.get("max_flow_block_minutes",90)
 
 def handle_save_prefs(user_id, wake, sleep, focus, brk, flow_max):
-    if not user_id:
-        return _err("Not logged in.")
+    if not user_id: return _err("Not logged in.")
     ctx = _ensure_context(user_id)
-    ctx["preferences"].update({
-        "wake_time":              wake or "07:30",
-        "sleep_time":             sleep or "23:00",
-        "focus_peak":             focus or "Morning",
-        "break_duration_minutes": int(brk or 10),
-        "max_flow_block_minutes": int(flow_max or 90),
-    })
+    ctx["preferences"].update({"wake_time":wake or "07:30","sleep_time":sleep or "23:00","focus_peak":focus or "Morning","break_duration_minutes":int(brk or 10),"max_flow_block_minutes":int(flow_max or 90)})
     save_user_context(user_id, ctx)
     return _ok("Preferences saved!")
 
-
 def render_context_html(user_id):
-    if not user_id:
-        return "<p style='color:#334155'>Not logged in.</p>"
+    if not user_id: return "<p style='color:#334155'>Not logged in.</p>"
     ctx = load_user_context(user_id)
-    if not ctx:
-        return "<p style='color:#334155;font-size:13px'>No AI context yet. Complete a journaling session to start building it.</p>"
-
-    lp   = ctx.get("learned_patterns", {})
-    sf   = ctx.get("scheduling_feedback", {})
-    pref = ctx.get("preferences", {})
-
-    def row(label, val):
-        return (
-            f'<div style="display:flex;justify-content:space-between;padding:6px 0;border-bottom:1px solid #0d1117">'
-            f'<span style="color:#334155;font-size:12px">{label}</span>'
-            f'<span style="color:#94a3b8;font-size:12px;font-family:JetBrains Mono,monospace">{val}</span>'
-            f'</div>'
-        )
-    def lst(v): return ", ".join(v) if v else "—"
-
-    html = (
-        f'<div style="display:grid;grid-template-columns:1fr 1fr;gap:14px">'
-        f'<div class="panel">'
-        f'<div class="sec-label">Preferences</div>'
-        f'{row("Wake", pref.get("wake_time","—"))}'
-        f'{row("Sleep", pref.get("sleep_time","—"))}'
-        f'{row("Peak focus", pref.get("focus_peak","—"))}'
-        f'{row("Break", str(pref.get("break_duration_minutes","—")) + "min")}'
-        f'{row("Max flow block", str(pref.get("max_flow_block_minutes","—")) + "min")}'
-        f'</div>'
-        f'<div class="panel">'
-        f'<div class="sec-label">Scheduling Stats</div>'
-        f'{row("Days scheduled", sf.get("total_days_scheduled",0))}'
-        f'{row("Avg completion", str(round(sf.get("avg_completion_rate",0)*100)) + "%")}'
-        f'{row("Context version", ctx.get("version",1))}'
-        f'{row("Last updated", (ctx.get("last_updated","—") or "—")[:16])}'
-        f'</div>'
-        f'</div>'
-        f'<div class="panel" style="margin-top:14px">'
-        f'<div class="sec-label">Learned Patterns</div>'
-        f'{row("Productive times", lst(lp.get("productive_times",[])))}'
-        f'{row("Low energy times", lst(lp.get("low_energy_times",[])))}'
-        f'{row("Avg task overrun", str(lp.get("avg_task_overrun_pct",0)) + "%")}'
-        f'{row("Flow batchable", str(lp.get("flow_batch_capable","Unknown")))}'
-        f'{row("Best morning areas", lst(lp.get("best_life_areas_morning",[])))}'
-        f'{row("Skipped types", lst(lp.get("common_skipped_task_types",[])))}'
-        f'</div>'
-    )
-
-    notes = lp.get("notes", [])
+    if not ctx: return "<p style='color:#334155;font-size:13px'>No AI context yet. Complete a journal session to build it.</p>"
+    lp = ctx.get("learned_patterns",{}); sf = ctx.get("scheduling_feedback",{}); pref = ctx.get("preferences",{})
+    def _row(l,v): return f'<div style="display:flex;justify-content:space-between;padding:5px 0;border-bottom:1px solid #1e293b"><span style="color:#475569;font-size:12px">{l}</span><span style="color:#cbd5e1;font-size:12px">{v}</span></div>'
+    def _hdr(t): return f'<div style="color:#a78bfa;font-size:10px;font-weight:600;letter-spacing:1px;text-transform:uppercase;margin:14px 0 8px">{t}</div>'
+    html = "<div style='font-size:13px'>" + _hdr("Preferences")
+    html += _row("Wake",pref.get("wake_time","—"))+_row("Sleep",pref.get("sleep_time","—"))+_row("Peak Focus",pref.get("focus_peak","—"))
+    html += _hdr("Learned Patterns")
+    html += _row("Avg overrun",f'{lp.get("avg_task_overrun_pct",0)}%')+_row("Flow batching",str(lp.get("flow_batch_capable","Unknown")))
+    html += _row("Days tracked",str(sf.get("total_days_scheduled",0)))+_row("Avg completion",f'{round(sf.get("avg_completion_rate",0)*100)}%')
+    notes = lp.get("notes",[])
     if notes:
-        note_rows = "".join(
-            f'<div style="padding:5px 0;border-bottom:1px solid #0d1117;color:#64748b;font-size:12px">• {n}</div>'
-            for n in notes[-5:]
-        )
-        html += f'<div class="panel" style="margin-top:14px"><div class="sec-label">AI Notes</div>{note_rows}</div>'
-
-    history = ctx.get("history_summary", [])
-    if history:
-        hist_rows = "".join(
-            f'<div style="padding:4px 0;color:#475569;font-size:12px">• {h}</div>'
-            for h in history[-5:]
-        )
-        html += f'<div class="panel" style="margin-top:14px"><div class="sec-label">Recent History</div>{hist_rows}</div>'
-
+        html += _hdr("AI Notes")
+        html += "".join(f'<div style="color:#94a3b8;font-size:12px;padding:3px 0">• {n}</div>' for n in notes[-5:])
+    html += f'<div style="color:#334155;font-size:11px;margin-top:12px">v{ctx.get("version",1)} · {ctx.get("last_updated","—")[:10]}</div></div>'
     return html
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# UI BUILD
+# UI
 # ═══════════════════════════════════════════════════════════════════════════════
 
 with gr.Blocks(title="🧠 Second Brain") as demo:
 
-    # ── Session state ──────────────────────────────────────────────────────────
-    user_id_state   = gr.State(None)
-    username_state  = gr.State("")
-    # Journal states
-    journal_chat_state  = gr.State([])
+    user_id_state  = gr.State(None)
+    username_state = gr.State("")
+    # Journal
     journal_hist_state  = gr.State([])
     journal_tasks_state = gr.State([])
     journal_active      = gr.State(False)
-    # Clarification states
+    journal_phase_state = gr.State("marking")
+    # Clarification — text panel
     clar_questions_state = gr.State([])
     original_task_state  = gr.State("")
+    # Clarification — voice panel
+    vclar_questions_state = gr.State([])
+    voriginal_task_state  = gr.State("")
 
-    # ═════════════════════════════════════════════════════════════════════════
-    # AUTH SECTION
-    # ═════════════════════════════════════════════════════════════════════════
+    # ── AUTH ──────────────────────────────────────────────────────────────────
     with gr.Column(visible=True, elem_id="auth-card") as auth_section:
         gr.HTML('<div id="brand-logo">🧠 Second Brain</div>')
         gr.HTML('<div id="brand-sub">Your intelligent productivity companion</div>')
-
         with gr.Tabs():
-            # ── Sign In ────────────────────────────────────────────────────
             with gr.Tab("Sign In"):
                 login_user_in = gr.Textbox(label="Username", placeholder="your username")
                 login_pass_in = gr.Textbox(label="Password", type="password", placeholder="••••••••")
                 login_btn     = gr.Button("Sign In", elem_classes="btn-primary")
                 login_msg     = gr.HTML("")
-
-            # ── Create Account ─────────────────────────────────────────────
             with gr.Tab("Create Account"):
-                reg_user_in  = gr.Textbox(label="Username", placeholder="choose a username")
-                reg_pass_in  = gr.Textbox(label="Password (min 6 chars)", type="password", placeholder="••••••••")
-                reg_wake  = gr.Textbox(label="Wake time",  value="07:30")
-                reg_sleep = gr.Textbox(label="Sleep time", value="23:00")
-                reg_focus = gr.Dropdown(label="Peak focus",
-                                        choices=["Morning","Afternoon","Evening","Night"],
-                                        value="Morning")
-                reg_goals = gr.Textbox(
-                    label="Big-picture goals (one per line, optional)",
-                    lines=3,
-                    placeholder="Launch my startup\nGet fit\nLearn machine learning"
-                )
-                reg_btn  = gr.Button("Create Account", elem_classes="btn-primary")
-                reg_msg  = gr.HTML("")
-
-    # ═════════════════════════════════════════════════════════════════════════
-    # MAIN APP SECTION
-    # ═════════════════════════════════════════════════════════════════════════
+                reg_user_in = gr.Textbox(label="Username",               placeholder="choose a username")
+                reg_pass_in = gr.Textbox(label="Password (min 6 chars)", type="password", placeholder="••••••••")
+                reg_wake    = gr.Textbox(label="Wake time",  value="07:30")
+                reg_sleep   = gr.Textbox(label="Sleep time", value="23:00")
+                reg_focus   = gr.Dropdown(label="Peak focus", choices=["Morning","Afternoon","Evening","Night"], value="Morning")
+                reg_goals   = gr.Textbox(label="Big-picture goals (one per line, optional)", lines=3, placeholder="Launch my startup\nGet fit\nLearn ML")
+                reg_btn     = gr.Button("Create Account", elem_classes="btn-primary")
+                reg_msg     = gr.HTML("")
+
+    # ── MAIN APP ──────────────────────────────────────────────────────────────
     with gr.Column(visible=False) as app_section:
 
-        # ── Top header ─────────────────────────────────────────────────────
         with gr.Row(elem_id="top-header"):
             header_html = gr.HTML('<div id="top-header-brand">🧠 Second Brain</div><div id="top-header-user">—</div>')
             logout_btn  = gr.Button("Sign Out", elem_classes="btn-secondary", scale=0)
 
-        # ── Tabs ────────────────────────────────────────────────────────────
-        with gr.Tabs() as main_tabs:
+        with gr.Tabs():
 
-            # ─────────────────────────────────────────────────────────────
-            # TAB 1: TODAY
-            # ─────────────────────────────────────────────────────────────
+            # ── TAB 1: TODAY ─────────────────────────────────────────────────
             with gr.Tab("📅 Today"):
-                # Stats row
                 with gr.Row():
                     stat_total  = gr.HTML(_stat("—","Today","#a78bfa"))
                     stat_done   = gr.HTML(_stat("—","Done","#4ade80"))
                     stat_remain = gr.HTML(_stat("—","Left","#f87171"))
-
-                # Action buttons
                 with gr.Row():
                     btn_add_text  = gr.Button("✏️ Add Task (Text)",  elem_classes="btn-primary",   scale=3)
                     btn_add_voice = gr.Button("🎙️ Add Task (Voice)", elem_classes="btn-accent",    scale=3)
                     btn_plan_day  = gr.Button("🗓 Plan My Day",       elem_classes="btn-secondary", scale=3)
                     btn_refresh   = gr.Button("↻",                    elem_classes="btn-secondary", scale=1)
 
-                # ── Text add panel ────────────────────────────────────────
+                # ── Text panel ────────────────────────────────────────────────
                 with gr.Column(visible=False, elem_classes="panel") as text_panel:
                     gr.HTML('<div class="sec-label">Describe Your Task</div>')
-                    task_input = gr.Textbox(
-                        label="",
-                        placeholder="e.g. Finish the client proposal by tomorrow, it's really important",
-                        lines=2
-                    )
+                    task_input = gr.Textbox(label="", placeholder="e.g. Finish the client proposal by tomorrow, it's really important", lines=2)
                     with gr.Row():
-                        btn_parse  = gr.Button("🤖 Parse with AI", elem_classes="btn-primary")
-                        btn_cancel_text = gr.Button("Cancel", elem_classes="btn-secondary")
+                        btn_parse       = gr.Button("🤖 Parse with AI", elem_classes="btn-primary")
+                        btn_cancel_text = gr.Button("Cancel",           elem_classes="btn-secondary")
 
                     with gr.Column(visible=False) as parsed_panel:
                         parse_status = gr.HTML("")
                         clar_html    = gr.HTML("")
-                        # ── Clarification reply row (shown only when AI has questions) ──
                         with gr.Column(visible=False) as clar_reply_row:
-                            gr.HTML('<div class="sec-label" style="margin-top:8px">Your Answer</div>')
-                            clar_reply_input = gr.Textbox(
-                                label="",
-                                placeholder="e.g. It's for a client deadline, very high priority, should take about 2 hours",
-                                lines=2
-                            )
-                            btn_clar_submit = gr.Button("🔄 Re-classify with my answer", elem_classes="btn-accent")
+                            gr.HTML('<div class="sec-label" style="margin-top:8px">Answer the questions above</div>')
+                            with gr.Row():
+                                clar_text_input  = gr.Textbox(label="Type your answer", lines=2, scale=4,
+                                                               placeholder="e.g. It's urgent, about 2 hours, for my manager")
+                                clar_audio_input = gr.Audio(sources=["microphone"], type="filepath",
+                                                             label="🎙 Or speak", scale=1)
+                            btn_clar_submit = gr.Button("🔄 Re-classify", elem_classes="btn-accent")
                         gr.HTML('<div class="sec-label" style="margin-top:12px">Review & Confirm</div>')
                         with gr.Row():
                             f_title = gr.Textbox(label="Title", scale=3)
-                            f_area  = gr.Dropdown(label="Life Area",
-                                                  choices=["Work","Health","Finance","Learning","Personal","Family","Other"],
-                                                  scale=1)
+                            f_area  = gr.Dropdown(label="Life Area", choices=["Work","Health","Finance","Learning","Personal","Family","Other"], scale=1)
                         with gr.Row():
-                            f_urgency    = gr.Dropdown(label="Urgency",
-                                                       choices=["Urgent","Not Urgent","Habit"], value="Not Urgent")
-                            f_importance = gr.Dropdown(label="Importance",
-                                                       choices=["Move the Needle","Important","Not Important"],
-                                                       value="Important")
-                            f_state      = gr.Dropdown(label="State of Mind",
-                                                       choices=["Flow","Easy","Quick","Personal"], value="Easy")
+                            f_urgency    = gr.Dropdown(label="Urgency",       choices=["Urgent","Not Urgent","Habit"],                value="Not Urgent")
+                            f_importance = gr.Dropdown(label="Importance",    choices=["Move the Needle","Important","Not Important"], value="Important")
+                            f_state      = gr.Dropdown(label="State of Mind", choices=["Flow","Easy","Quick","Personal"],             value="Easy")
                         with gr.Row():
-                            f_time    = gr.Number(label="Minutes", value=30, minimum=5, scale=1)
-                            f_date    = gr.Textbox(label="Scheduled Date", value=str(date.today()), scale=1)
+                            f_time     = gr.Number(label="Minutes", value=30, minimum=5, scale=1)
+                            f_date     = gr.Textbox(label="Scheduled Date", value=str(date.today()), scale=1)
                             f_is_habit = gr.Checkbox(label="♻️ This is a habit", scale=1)
-                            f_interval = gr.Dropdown(label="Recurs",
-                                                     choices=["Daily","Weekly","Weekdays","Weekends","Monthly"],
-                                                     value="Daily", visible=False, scale=1)
+                            f_interval = gr.Dropdown(label="Recurs", choices=["Daily","Weekly","Weekdays","Weekends","Monthly"], value="Daily", visible=False, scale=1)
                         with gr.Row():
                             btn_confirm = gr.Button("✓ Save Task", elem_classes="btn-success")
                             btn_discard = gr.Button("✗ Discard",   elem_classes="btn-danger")
                         save_msg = gr.HTML("")
 
-                # ── Voice add panel ───────────────────────────────────────
+                # ── Voice panel ───────────────────────────────────────────────
                 with gr.Column(visible=False, elem_classes="panel") as voice_panel:
-                    gr.HTML('<div class="sec-label">Record or Upload Audio</div>')
-                    gr.HTML('<p style="color:#334155;font-size:13px;margin-bottom:12px">Whisper transcribes it, then AI classifies the task automatically.</p>')
-                    audio_input = gr.Audio(sources=["microphone","upload"], type="filepath", label="")
-                    transcribed = gr.Textbox(label="Transcribed text (editable before parsing)",
-                                             visible=False, lines=2)
+                    gr.HTML('<div class="sec-label">Add Task by Voice</div>')
+                    gr.HTML('<p style="color:#475569;font-size:13px;margin-bottom:12px">Record your task — Whisper transcribes it, then AI classifies it automatically. Same flow as text.</p>')
+                    voice_audio_input = gr.Audio(sources=["microphone","upload"], type="filepath", label="")
                     with gr.Row():
-                        btn_transcribe    = gr.Button("🤖 Transcribe & Parse", elem_classes="btn-primary")
-                        btn_cancel_voice  = gr.Button("Cancel", elem_classes="btn-secondary")
-                    voice_msg = gr.HTML("")
+                        btn_voice_parse  = gr.Button("🤖 Transcribe & Classify", elem_classes="btn-primary")
+                        btn_cancel_voice = gr.Button("Cancel",                   elem_classes="btn-secondary")
+                    voice_status = gr.HTML("")
+
+                    with gr.Column(visible=False) as voice_parsed_panel:
+                        voice_transcribed_txt = gr.Textbox(label="Transcribed text (editable)", lines=1)
+                        voice_clar_html       = gr.HTML("")
+                        with gr.Column(visible=False) as voice_clar_row:
+                            gr.HTML('<div class="sec-label" style="margin-top:8px">Answer the questions above</div>')
+                            with gr.Row():
+                                vclar_text  = gr.Textbox(label="Type your answer", lines=2, scale=4,
+                                                          placeholder="e.g. It's urgent, about 90 minutes, very high priority")
+                                vclar_audio = gr.Audio(sources=["microphone"], type="filepath", label="🎙 Or speak", scale=1)
+                            btn_vclar_submit = gr.Button("🔄 Re-classify", elem_classes="btn-accent")
+                        gr.HTML('<div class="sec-label" style="margin-top:12px">Review & Confirm</div>')
+                        with gr.Row():
+                            vf_title = gr.Textbox(label="Title", scale=3)
+                            vf_area  = gr.Dropdown(label="Life Area", choices=["Work","Health","Finance","Learning","Personal","Family","Other"], scale=1)
+                        with gr.Row():
+                            vf_urgency    = gr.Dropdown(label="Urgency",       choices=["Urgent","Not Urgent","Habit"],                value="Not Urgent")
+                            vf_importance = gr.Dropdown(label="Importance",    choices=["Move the Needle","Important","Not Important"], value="Important")
+                            vf_state      = gr.Dropdown(label="State of Mind", choices=["Flow","Easy","Quick","Personal"],             value="Easy")
+                        with gr.Row():
+                            vf_time     = gr.Number(label="Minutes", value=30, minimum=5, scale=1)
+                            vf_date     = gr.Textbox(label="Scheduled Date", value=str(date.today()), scale=1)
+                            vf_is_habit = gr.Checkbox(label="♻️ This is a habit", scale=1)
+                            vf_interval = gr.Dropdown(label="Recurs", choices=["Daily","Weekly","Weekdays","Weekends","Monthly"], value="Daily", visible=False, scale=1)
+                        with gr.Row():
+                            btn_voice_confirm = gr.Button("✓ Save Task", elem_classes="btn-success")
+                            btn_voice_discard = gr.Button("✗ Discard",   elem_classes="btn-danger")
+                        voice_save_msg = gr.HTML("")
 
-                # ── Plan My Day panel ─────────────────────────────────────
+                # ── Plan My Day panel ─────────────────────────────────────────
                 with gr.Column(visible=False, elem_classes="panel") as plan_panel:
                     gr.HTML('<div class="sec-label">Plan My Day</div>')
-                    gr.HTML('<p style="color:#334155;font-size:13px;margin-bottom:12px">The AI reads your tasks, context, and goals to build the optimal schedule.</p>')
-                    plan_prompt = gr.Textbox(
-                        label="Any fixed events or preferences today?",
-                        placeholder="e.g. I have a meeting at 10am, want deep work in the morning, done by 7pm",
-                        lines=3
-                    )
+                    gr.HTML('<p style="color:#475569;font-size:13px;margin-bottom:12px">AI reads your tasks, context, and goals to build the optimal time-blocked schedule.</p>')
+                    plan_prompt = gr.Textbox(label="Any fixed events or notes?", placeholder="e.g. Meeting at 10am, deep work morning, done by 7pm", lines=3)
                     with gr.Row():
-                        btn_gen_sched  = gr.Button("✨ Generate Schedule", elem_classes="btn-primary")
-                        btn_cancel_plan = gr.Button("Cancel", elem_classes="btn-secondary")
+                        btn_gen_sched   = gr.Button("✨ Generate Schedule", elem_classes="btn-primary")
+                        btn_cancel_plan = gr.Button("Cancel",               elem_classes="btn-secondary")
                     schedule_html = gr.HTML("")
 
-                # ── Today's task table ────────────────────────────────────
                 gr.HTML('<div class="sec-label" style="margin-top:20px">Today\'s Tasks</div>')
                 today_df = gr.Dataframe(headers=TASK_HEADERS, interactive=False, wrap=True)
                 with gr.Row():
-                    today_done_id = gr.Number(label="Task ID — toggle done", precision=0, scale=2)
+                    today_done_id  = gr.Number(label="Task ID — toggle done", precision=0, scale=2)
                     btn_today_done = gr.Button("✅ Mark Done", elem_classes="btn-success", scale=2)
                     today_del_id   = gr.Number(label="Task ID — delete",      precision=0, scale=2)
                     btn_today_del  = gr.Button("🗑 Delete",    elem_classes="btn-danger",  scale=2)
                 today_action_msg = gr.HTML("")
 
-            # ─────────────────────────────────────────────────────────────
-            # TAB 2: ALL TASKS
-            # ─────────────────────────────────────────────────────────────
+            # ── TAB 2: ALL TASKS ─────────────────────────────────────────────
             with gr.Tab("📋 All Tasks"):
                 with gr.Row():
                     all_filter    = gr.Dropdown(label="Filter by Area", choices=["All"], value="All", scale=4)
                     all_today_chk = gr.Checkbox(label="Today only", value=False, scale=1)
                     btn_all_ref   = gr.Button("↻ Refresh", elem_classes="btn-secondary", scale=1)
-
                 all_df = gr.Dataframe(headers=TASK_HEADERS, interactive=False, wrap=True)
                 with gr.Row():
                     all_done_id  = gr.Number(label="Task ID — toggle done", precision=0, scale=2)
@@ -819,347 +680,217 @@ with gr.Blocks(title="🧠 Second Brain") as demo:
                     btn_all_del  = gr.Button("🗑 Delete", elem_classes="btn-danger",  scale=2)
                 all_action_msg = gr.HTML("")
 
-            # ─────────────────────────────────────────────────────────────
-            # TAB 3: JOURNAL
-            # ─────────────────────────────────────────────────────────────
+            # ── TAB 3: JOURNAL ──────────────────────────────────────────��────
             with gr.Tab("📓 Journal"):
-                gr.HTML('<p style="color:#334155;font-size:13px;margin-bottom:16px">Mark today\'s tasks complete, then reflect. The AI updates your profile to improve tomorrow\'s schedule.</p>')
-
-                # Step 1 — Mark tasks
-                with gr.Column(elem_classes="panel"):
-                    gr.HTML('<div class="sec-label">Step 1 — Mark Tasks Complete</div>')
-                    journal_task_list = gr.HTML('<p style="color:#334155;font-size:13px">Click "Load Tasks" to begin.</p>')
-                    btn_load_tasks    = gr.Button("Load Today's Tasks", elem_classes="btn-secondary")
-                    with gr.Row(visible=False) as journal_mark_row:
-                        j_task_id    = gr.Number(label="Task ID", precision=0, scale=2)
-                        j_actual_min = gr.Number(label="Actual time (min)", precision=0, value=0, scale=2)
-                        btn_j_done   = gr.Button("✅ Mark Complete", elem_classes="btn-success", scale=2)
-                        btn_j_undone = gr.Button("↩ Unmark",         elem_classes="btn-secondary", scale=1)
-                    journal_mark_msg = gr.HTML("")
-
-                # Step 2 — Chat
-                with gr.Column(elem_classes="panel"):
-                    gr.HTML('<div class="sec-label">Step 2 — Reflect</div>')
-                    journal_chatbot = gr.Chatbot(label="", height=380)
-                    with gr.Row():
-                        btn_j_start   = gr.Button("▶ Start Reflection",     elem_classes="btn-primary",   scale=2)
-                        btn_j_finish  = gr.Button("✓ Finish & Save Insights", elem_classes="btn-success",   scale=2)
-                        btn_j_restart = gr.Button("↺ Restart",               elem_classes="btn-secondary", scale=1)
-                    j_answer  = gr.Textbox(label="Your answer", placeholder="Type here…", lines=2, interactive=False)
-                    btn_j_send = gr.Button("Send →", elem_classes="btn-accent", interactive=False)
-                    journal_msg = gr.HTML("")
-
-            # ─────────────────────────────────────────────────────────────
-            # TAB 4: LIFE AREAS & GOALS
-            # ─────────────────────────────────────────────────────────────
+                gr.HTML('<p style="color:#475569;font-size:13px;margin-bottom:12px">End-of-day reflection. Chat naturally — the AI marks tasks, asks questions, and updates your profile.</p>')
+                journal_chatbot = gr.Chatbot(
+                    label="", height=440, type="messages",
+                    placeholder="<p style='color:#334155;text-align:center;padding-top:80px'>Click <b>▶ Start Session</b> to begin</p>",
+                )
+                with gr.Row():
+                    j_answer   = gr.Textbox(label="", placeholder="Type or use the mic…", lines=1,
+                                             scale=5, interactive=False, show_label=False)
+                    j_audio_in = gr.Audio(sources=["microphone"], type="filepath",
+                                          label="🎙", scale=1, interactive=False)
+                    btn_j_send = gr.Button("Send →", elem_classes="btn-accent", scale=1, interactive=False)
+                with gr.Row():
+                    btn_j_start   = gr.Button("▶ Start Session",  elem_classes="btn-primary",   scale=3)
+                    btn_j_finish  = gr.Button("✓ Finish & Save",   elem_classes="btn-success",   scale=3)
+                    btn_j_restart = gr.Button("↺ Reset",           elem_classes="btn-secondary", scale=1)
+                journal_msg = gr.HTML("")
+
+            # ── TAB 4: AREAS & GOALS ─────────────────────────────────────────
             with gr.Tab("🗂 Areas & Goals"):
                 gr.HTML('<div class="sec-label">Your Life Areas</div>')
                 areas_display = gr.HTML("")
-
                 with gr.Row():
                     new_area_name  = gr.Textbox(label="New area name", placeholder="e.g. Side Project", scale=3)
                     new_area_color = gr.ColorPicker(label="Color", value="#6366f1", scale=1)
                     btn_add_area   = gr.Button("Add", elem_classes="btn-primary", scale=1)
                 area_msg = gr.HTML("")
-
                 gr.HTML('<div class="sec-label" style="margin-top:24px">Remove Area</div>')
                 with gr.Row():
                     del_area_dd  = gr.Dropdown(label="Select area to remove", choices=[], scale=4)
                     btn_del_area = gr.Button("Remove", elem_classes="btn-danger", scale=1)
                 del_area_msg = gr.HTML("")
-
                 gr.HTML('<hr>')
                 gr.HTML('<div class="sec-label">Big-Picture Goals</div>')
-                gr.HTML('<p style="color:#334155;font-size:13px;margin-bottom:10px">The AI uses these when scheduling and prioritising your tasks.</p>')
-                goals_input     = gr.Textbox(label="One goal per line", lines=5,
-                                             placeholder="Launch my SaaS\nRun 5K\nLearn ML")
-                btn_save_goals  = gr.Button("Save Goals", elem_classes="btn-primary")
-                goals_msg       = gr.HTML("")
-
-            # ─────────────────────────────────────────────────────────────
-            # TAB 5: PREFERENCES
-            # ─────────────────────────────────────────────────────────────
+                gr.HTML('<p style="color:#475569;font-size:13px;margin-bottom:10px">The AI factors these in when scheduling and prioritising.</p>')
+                goals_input    = gr.Textbox(label="One goal per line", lines=5, placeholder="Launch my SaaS\nRun 5K\nLearn ML")
+                btn_save_goals = gr.Button("Save Goals", elem_classes="btn-primary")
+                goals_msg      = gr.HTML("")
+
+            # ── TAB 5: PREFERENCES ───────────────────────────────────────────
             with gr.Tab("⚙️ Preferences"):
                 gr.HTML('<div class="sec-label">Scheduling Preferences</div>')
                 with gr.Row():
                     pref_wake  = gr.Textbox(label="Wake time",  placeholder="07:30", scale=1)
                     pref_sleep = gr.Textbox(label="Sleep time", placeholder="23:00", scale=1)
-                    pref_focus = gr.Dropdown(label="Peak focus",
-                                             choices=["Morning","Afternoon","Evening","Night"],
-                                             value="Morning", scale=1)
+                    pref_focus = gr.Dropdown(label="Peak focus", choices=["Morning","Afternoon","Evening","Night"], value="Morning", scale=1)
                 with gr.Row():
                     pref_break    = gr.Number(label="Break between tasks (min)", value=10, minimum=0, scale=1)
                     pref_flow_max = gr.Number(label="Max Flow block (min)",      value=90, minimum=30, scale=1)
                 btn_save_prefs = gr.Button("Save Preferences", elem_classes="btn-primary")
                 prefs_msg = gr.HTML("")
-
                 gr.HTML('<hr>')
                 gr.HTML('<div class="sec-label">AI Memory</div>')
-                gr.HTML('<p style="color:#334155;font-size:13px;margin-bottom:10px">Everything the AI has learned about you. Updates after each journaling session.</p>')
-                ctx_display  = gr.HTML("")
-                btn_ref_ctx  = gr.Button("↻ Refresh", elem_classes="btn-secondary")
+                gr.HTML('<p style="color:#475569;font-size:13px;margin-bottom:10px">Everything the AI has learned about you. Updates after each journal session.</p>')
+                ctx_display = gr.HTML("")
+                btn_ref_ctx = gr.Button("↻ Refresh", elem_classes="btn-secondary")
 
-
-    # ═══════════════════════════════════════════════════════════════════════
+    # ═════════════════════════════════════════════════════════════════════════
     # EVENT WIRING
-    # ═══════════════════════════════════════════════════════════════════════
-
-    # ── Auth ──────────────────────────────────────────────────────────────
+    # ═════════════════════════════════════════════════════════════════════════
 
-    def _post_login(uid, uname):
-        if not uid:
-            return uid, uname
-        spawn_due_habits(uid)
-        return uid, uname
+    # ── Auth ──────────────────────────────────────────────────────────────────
+    def _header_html(uid, uname):
+        return f'<div id="top-header-brand">🧠 Second Brain</div><div id="top-header-user">👤 {uname}</div>'
 
-    login_btn.click(
-        handle_login,
-        [login_user_in, login_pass_in],
+    login_btn.click(handle_login, [login_user_in, login_pass_in],
         [user_id_state, username_state, login_msg, auth_section, app_section]
-    ).then(
-        lambda uid, uname: f'<div id="top-header-brand">🧠 Second Brain</div><div id="top-header-user">👤 {uname}</div>',
-        [user_id_state, username_state], [header_html]
-    ).then(
-        refresh_today, [user_id_state],
-        [today_df, stat_total, stat_done, stat_remain]
-    ).then(
-        lambda uid: render_areas(uid)[0:2],
-        [user_id_state], [areas_display, del_area_dd]
-    ).then(
-        load_goals_txt, [user_id_state], [goals_input]
-    ).then(
-        lambda uid: load_prefs(uid),
-        [user_id_state], [pref_wake, pref_sleep, pref_focus, pref_break, pref_flow_max]
-    )
+    ).then(_header_html, [user_id_state, username_state], [header_html]
+    ).then(refresh_today, [user_id_state], [today_df, stat_total, stat_done, stat_remain]
+    ).then(lambda uid: render_areas(uid)[:2], [user_id_state], [areas_display, del_area_dd]
+    ).then(load_prefs, [user_id_state], [pref_wake, pref_sleep, pref_focus, pref_break, pref_flow_max]
+    ).then(load_goals_txt, [user_id_state], [goals_input])
 
-    reg_btn.click(
-        handle_register,
-        [reg_user_in, reg_pass_in, reg_wake, reg_sleep, reg_focus, reg_goals],
+    reg_btn.click(handle_register, [reg_user_in, reg_pass_in, reg_wake, reg_sleep, reg_focus, reg_goals],
         [user_id_state, username_state, reg_msg, auth_section, app_section]
-    ).then(
-        lambda uid, uname: f'<div id="top-header-brand">🧠 Second Brain</div><div id="top-header-user">👤 {uname}</div>',
-        [user_id_state, username_state], [header_html]
-    ).then(
-        refresh_today, [user_id_state],
-        [today_df, stat_total, stat_done, stat_remain]
-    ).then(
-        lambda uid: render_areas(uid)[0:2],
-        [user_id_state], [areas_display, del_area_dd]
-    )
-
-    logout_btn.click(
-        handle_logout,
-        [user_id_state],
-        [user_id_state, username_state, auth_section, app_section]
-    )
+    ).then(_header_html, [user_id_state, username_state], [header_html]
+    ).then(refresh_today, [user_id_state], [today_df, stat_total, stat_done, stat_remain]
+    ).then(lambda uid: render_areas(uid)[:2], [user_id_state], [areas_display, del_area_dd])
 
-    # ── Today tab ─────────────────────────────────────────────────────────
+    logout_btn.click(handle_logout, [user_id_state], [user_id_state, username_state, auth_section, app_section])
 
+    # ── Panels ────────────────────────────────────────────────────────────────
     btn_add_text.click(show_text_panel,  outputs=[text_panel, voice_panel, plan_panel])
     btn_add_voice.click(show_voice_panel, outputs=[text_panel, voice_panel, plan_panel])
     btn_plan_day.click(show_plan_panel,   outputs=[text_panel, voice_panel, plan_panel])
     btn_cancel_text.click(hide_panels,    outputs=[text_panel, voice_panel, plan_panel])
     btn_cancel_voice.click(hide_panels,   outputs=[text_panel, voice_panel, plan_panel])
     btn_cancel_plan.click(hide_panels,    outputs=[text_panel, voice_panel, plan_panel])
+    btn_refresh.click(refresh_today, [user_id_state], [today_df, stat_total, stat_done, stat_remain])
 
-    btn_refresh.click(
-        refresh_today, [user_id_state],
-        [today_df, stat_total, stat_done, stat_remain]
-    )
+    f_is_habit.change(lambda v: gr.update(visible=v), [f_is_habit], [f_interval])
+    vf_is_habit.change(lambda v: gr.update(visible=v), [vf_is_habit], [vf_interval])
 
-    # Show habit interval dropdown only when habit checked
-    f_is_habit.change(
-        lambda v: gr.update(visible=v),
-        [f_is_habit], [f_interval]
-    )
+    # ── Text task flow ─────────────────────────────────────────────────────────
+    _TEXT_PARSE_OUTPUTS = [parsed_panel, f_title, clar_html, f_area, f_urgency, f_importance,
+                           f_state, f_time, f_date, f_is_habit, f_interval, parse_status,
+                           clar_reply_row, clar_questions_state, original_task_state]
+    _TEXT_CLAR_OUTPUTS  = [f_title, clar_html, f_area, f_urgency, f_importance,
+                           f_state, f_time, clar_reply_row, clar_questions_state]
 
-    btn_parse.click(
-        handle_parse_text,
-        [task_input, user_id_state],
-        [parsed_panel, f_title, clar_html, f_area, f_urgency, f_importance,
-         f_state, f_time, f_date, f_is_habit, f_interval, parse_status,
-         clar_reply_row, clar_questions_state, original_task_state]
-    )
+    btn_parse.click(handle_parse_text, [task_input, user_id_state], _TEXT_PARSE_OUTPUTS)
 
     btn_clar_submit.click(
         handle_clarification_reply,
-        [clar_reply_input, original_task_state, clar_questions_state, user_id_state],
-        [f_title, clar_html, f_area, f_urgency, f_importance,
-         f_state, f_time, clar_reply_row, clar_questions_state]
-    ).then(
-        lambda: "",
-        outputs=[clar_reply_input]
-    )
-
-    btn_transcribe.click(
-        handle_transcribe_voice,
-        [audio_input, user_id_state],
-        [transcribed, voice_msg]
-    )
+        [clar_text_input, original_task_state, clar_questions_state, user_id_state],
+        _TEXT_CLAR_OUTPUTS
+    ).then(lambda: ("", None), outputs=[clar_text_input, clar_audio_input])
 
-    btn_discard.click(
-        lambda: gr.update(visible=False),
-        outputs=[parsed_panel]
-    )
+    clar_audio_input.change(
+        handle_clar_voice,
+        [clar_audio_input, original_task_state, clar_questions_state, user_id_state],
+        _TEXT_CLAR_OUTPUTS
+    ).then(lambda: None, outputs=[clar_audio_input])
 
+    btn_discard.click(lambda: gr.update(visible=False), outputs=[parsed_panel])
     btn_confirm.click(
         handle_confirm_task,
-        [user_id_state, f_title, f_area, f_urgency, f_importance, f_state,
-         f_time, f_date, f_is_habit, f_interval],
+        [user_id_state, f_title, f_area, f_urgency, f_importance, f_state, f_time, f_date, f_is_habit, f_interval],
         [save_msg, today_df, stat_total, stat_done, stat_remain, parsed_panel]
     )
 
-    btn_gen_sched.click(
-        handle_generate_schedule,
-        [user_id_state, plan_prompt],
-        [schedule_html]
-    )
-
-    btn_today_done.click(
-        handle_toggle_today,
-        [today_done_id, user_id_state],
-        [today_df, stat_total, stat_done, stat_remain, today_action_msg]
-    )
-    btn_today_del.click(
-        handle_delete_today,
-        [today_del_id, user_id_state],
-        [today_df, stat_total, stat_done, stat_remain, today_action_msg]
-    )
-
-    # ── All Tasks tab ──────────────────────────────────────────────────────
-
-    btn_all_ref.click(
-        refresh_all_tasks,
-        [user_id_state, all_filter, all_today_chk],
-        [all_df]
-    )
-    all_filter.change(
-        refresh_all_tasks,
-        [user_id_state, all_filter, all_today_chk],
-        [all_df]
-    )
-    all_today_chk.change(
-        refresh_all_tasks,
-        [user_id_state, all_filter, all_today_chk],
-        [all_df]
-    )
-    btn_all_done.click(
-        handle_toggle_all,
-        [all_done_id, user_id_state, all_filter, all_today_chk],
-        [all_df, all_action_msg]
-    )
-    btn_all_del.click(
-        handle_delete_all,
-        [all_del_id, user_id_state, all_filter, all_today_chk],
-        [all_df, all_action_msg]
-    )
-
-    # ── Journal tab ────────────────────────────────────────────────────────
+    # ── Voice task flow ────────────────────────────────────────────────────────
+    _VOICE_PARSE_OUTPUTS = [voice_parsed_panel, voice_transcribed_txt,
+                            voice_clar_html, vf_area, vf_urgency, vf_importance,
+                            vf_state, vf_time, vf_date, vf_is_habit, vf_interval,
+                            voice_status, voice_clar_row,
+                            vclar_questions_state, voriginal_task_state]
+    _VOICE_CLAR_OUTPUTS  = [vf_title, voice_clar_html, vf_area, vf_urgency, vf_importance,
+                            vf_state, vf_time, voice_clar_row, vclar_questions_state]
 
-    btn_load_tasks.click(
-        handle_load_journal_tasks,
-        [user_id_state],
-        [journal_task_list, journal_mark_row, journal_tasks_state]
-    )
+    btn_voice_parse.click(handle_voice_parse, [voice_audio_input, user_id_state], _VOICE_PARSE_OUTPUTS)
 
-    btn_j_done.click(
-        lambda tid, mins, uid, st: handle_journal_mark(tid, mins, uid, st, True),
-        [j_task_id, j_actual_min, user_id_state, journal_tasks_state],
-        [journal_tasks_state, journal_mark_msg]
-    ).then(
-        handle_load_journal_tasks,
-        [user_id_state],
-        [journal_task_list, journal_mark_row, journal_tasks_state]
-    )
-
-    btn_j_undone.click(
-        lambda tid, mins, uid, st: handle_journal_mark(tid, mins, uid, st, False),
-        [j_task_id, j_actual_min, user_id_state, journal_tasks_state],
-        [journal_tasks_state, journal_mark_msg]
-    ).then(
-        handle_load_journal_tasks,
-        [user_id_state],
-        [journal_task_list, journal_mark_row, journal_tasks_state]
-    )
-
-    btn_j_start.click(
-        handle_start_journal,
-        [user_id_state, journal_tasks_state],
-        [journal_chatbot, journal_hist_state, journal_active,
-         j_answer, btn_j_send, journal_msg]
-    )
-
-    btn_j_send.click(
-        handle_send_answer,
-        [user_id_state, j_answer, journal_chatbot, journal_hist_state,
-         journal_tasks_state, journal_active],
-        [journal_chatbot, journal_hist_state, j_answer, journal_msg]
-    )
-
-    j_answer.submit(
-        handle_send_answer,
-        [user_id_state, j_answer, journal_chatbot, journal_hist_state,
-         journal_tasks_state, journal_active],
-        [journal_chatbot, journal_hist_state, j_answer, journal_msg]
-    )
+    btn_vclar_submit.click(
+        handle_clarification_reply,
+        [vclar_text, voriginal_task_state, vclar_questions_state, user_id_state],
+        _VOICE_CLAR_OUTPUTS
+    ).then(lambda: ("", None), outputs=[vclar_text, vclar_audio])
+
+    vclar_audio.change(
+        handle_clar_voice,
+        [vclar_audio, voriginal_task_state, vclar_questions_state, user_id_state],
+        _VOICE_CLAR_OUTPUTS
+    ).then(lambda: None, outputs=[vclar_audio])
+
+    btn_voice_discard.click(lambda: gr.update(visible=False), outputs=[voice_parsed_panel])
+    btn_voice_confirm.click(
+        handle_confirm_task,
+        [user_id_state, vf_title, vf_area, vf_urgency, vf_importance, vf_state, vf_time, vf_date, vf_is_habit, vf_interval],
+        [voice_save_msg, today_df, stat_total, stat_done, stat_remain, voice_parsed_panel]
+    )
+
+    # ── Schedule ───────────────────────────────────────────────────────────────
+    btn_gen_sched.click(handle_generate_schedule, [user_id_state, plan_prompt], [schedule_html])
+    btn_today_done.click(handle_toggle_today, [today_done_id, user_id_state], [today_df, stat_total, stat_done, stat_remain, today_action_msg])
+    btn_today_del.click(handle_delete_today,   [today_del_id, user_id_state],  [today_df, stat_total, stat_done, stat_remain, today_action_msg])
+
+    # ── All Tasks ──────────────────────────────────────────────────────────────
+    btn_all_ref.click(refresh_all_tasks,   [user_id_state, all_filter, all_today_chk], [all_df])
+    all_filter.change(refresh_all_tasks,   [user_id_state, all_filter, all_today_chk], [all_df])
+    all_today_chk.change(refresh_all_tasks,[user_id_state, all_filter, all_today_chk], [all_df])
+    btn_all_done.click(handle_toggle_all,  [all_done_id, user_id_state, all_filter, all_today_chk], [all_df, all_action_msg])
+    btn_all_del.click(handle_delete_all,   [all_del_id,  user_id_state, all_filter, all_today_chk], [all_df, all_action_msg])
+
+    # ── Journal ────────────────────────────────────────────────────────────────
+    _J_START_OUTPUTS = [journal_chatbot, journal_hist_state, journal_active,
+                        j_answer, btn_j_send, j_audio_in, journal_tasks_state,
+                        journal_phase_state, journal_msg]
+    _J_MSG_INPUTS  = [user_id_state, j_answer, j_audio_in, journal_chatbot,
+                      journal_hist_state, journal_tasks_state, journal_active, journal_phase_state]
+    _J_MSG_OUTPUTS = [journal_chatbot, journal_hist_state, j_answer, j_audio_in,
+                      journal_tasks_state, journal_active, journal_phase_state, journal_msg]
+
+    btn_j_start.click(handle_start_journal, [user_id_state], _J_START_OUTPUTS)
+    btn_j_send.click(handle_journal_message, _J_MSG_INPUTS, _J_MSG_OUTPUTS)
+    j_answer.submit(handle_journal_message,  _J_MSG_INPUTS, _J_MSG_OUTPUTS)
+    j_audio_in.change(handle_journal_message, _J_MSG_INPUTS, _J_MSG_OUTPUTS)
 
     btn_j_finish.click(
         handle_finish_journal,
         [user_id_state, journal_chatbot, journal_hist_state, journal_tasks_state],
         [journal_chatbot, journal_msg]
     )
-
     btn_j_restart.click(
         handle_restart_journal,
         outputs=[journal_chatbot, journal_hist_state, journal_active,
-                 j_answer, btn_j_send, journal_msg]
+                 j_answer, btn_j_send, j_audio_in, journal_tasks_state,
+                 journal_phase_state, journal_msg]
     )
 
-    # ── Areas & Goals tab ─────────────────────────────────────────────────
-
+    # ── Areas & Goals ──────────────────────────────────────────────────────────
     btn_add_area.click(
-        handle_add_area,
-        [user_id_state, new_area_name, new_area_color],
+        handle_add_area, [user_id_state, new_area_name, new_area_color],
         [area_msg, areas_display, del_area_dd, new_area_name]
-    ).then(
-        lambda uid: gr.update(choices=_area_choices(uid), value="All"),
-        [user_id_state], [all_filter]
-    )
+    ).then(lambda uid: gr.update(choices=_area_choices(uid), value="All"), [user_id_state], [all_filter])
 
     btn_del_area.click(
-        handle_del_area,
-        [user_id_state, del_area_dd],
+        handle_del_area, [user_id_state, del_area_dd],
         [del_area_msg, areas_display, del_area_dd]
-    ).then(
-        lambda uid: gr.update(choices=_area_choices(uid), value="All"),
-        [user_id_state], [all_filter]
-    )
+    ).then(lambda uid: gr.update(choices=_area_choices(uid), value="All"), [user_id_state], [all_filter])
 
-    btn_save_goals.click(
-        handle_save_goals,
-        [user_id_state, goals_input],
-        [goals_msg]
-    )
-
-    # ── Preferences tab ───────────────────────────────────────────────────
+    btn_save_goals.click(handle_save_goals, [user_id_state, goals_input], [goals_msg])
 
+    # ── Preferences ────────────────────────────────────────────────────────────
     btn_save_prefs.click(
         handle_save_prefs,
         [user_id_state, pref_wake, pref_sleep, pref_focus, pref_break, pref_flow_max],
         [prefs_msg]
     )
-
-    btn_ref_ctx.click(
-        render_context_html,
-        [user_id_state],
-        [ctx_display]
-    )
-
-    # Refresh AI context display whenever the refresh button is clicked
-    # (Gradio Tabs.select doesn't support conditional output, so we use the button)
-
+    btn_ref_ctx.click(render_context_html, [user_id_state], [ctx_display])
 
 # ── Launch ─────────────────────────────────────────────────────────────────────
-
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, css=CSS)