Upload 6 files

README.md

@@ -1,14 +1,144 @@
 ---
 title: Second Brain
-emoji: 🐠
-colorFrom: purple
-colorTo: pink
+emoji: 🧠
+colorFrom: indigo
+colorTo: purple
 sdk: gradio
-sdk_version: 6.6.0
+sdk_version: "4.20.0"
 app_file: app.py
 pinned: false
-license: mit
-short_description: Personalized task scheduling and journling
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🧠 Second Brain
+
+An intelligent personal productivity app that learns how you work and schedules your day accordingly.
+
+## Features
+
+- **Task Capture** — type or speak tasks; AI classifies them across 4 dimensions automatically
+- **Life Areas** — every task belongs to one of your personal life areas (Work, Health, etc.)
+- **Smart Scheduling** — AI builds a time-blocked daily plan based on your tasks, context, and learned patterns
+- **Habit Tracking** — mark tasks as habits with a recurrence interval; they auto-spawn each day
+- **Goals** — define big-picture goals; AI factors them in when prioritizing
+- **Journaling** — end-of-day reflection that updates the AI's knowledge of how you work best
+
+## Project Structure
+
+```
+second_brain/
+├── app.py                  ← Main Gradio app, all UI + event wiring
+├── requirements.txt
+├── core/
+│   ├── __init__.py
+│   ├── database.py         ← SQLite: users, tasks, life areas, goals, AI context
+│   ├── ai_engine.py        ← All Groq API calls (task parsing, scheduling, journaling)
+│   └── styles.py           ← CSS
+└── ui/
+    └── __init__.py
+```
+
+---
+
+## Deploying to HuggingFace Spaces
+
+### Prerequisites
+- HuggingFace account with a Space already created (SDK: **Gradio**)
+- Free Groq API key from [console.groq.com](https://console.groq.com)
+
+---
+
+### Step-by-step
+
+#### 1. Add your Groq API key as a Secret
+
+In your Space on HuggingFace:
+
+1. Go to **Settings** → **Repository secrets**
+2. Click **New secret**
+3. Name: `GROQ_API_KEY`
+4. Value: your Groq key (starts with `gsk_`)
+5. Click **Add secret**
+
+> ⚠️ Never paste your API key directly into any file — use secrets only.
+
+---
+
+#### 2. Upload the files
+
+You have two options:
+
+**Option A — HuggingFace web UI (easiest)**
+
+1. Open your Space → click **Files** tab
+2. Upload these files maintaining the folder structure:
+   ```
+   app.py
+   requirements.txt
+   core/__init__.py
+   core/database.py
+   core/ai_engine.py
+   core/styles.py
+   ui/__init__.py
+   ```
+3. The Space rebuilds automatically on each upload
+
+**Option B — Git (recommended for updates)**
+
+```bash
+# Clone your Space repo
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# Copy project files in
+cp -r /path/to/second_brain/* .
+
+# Push
+git add .
+git commit -m "Initial deploy"
+git push
+```
+
+---
+
+#### 3. Wait for the build
+
+- HuggingFace will install `requirements.txt` automatically
+- First boot takes ~3–5 minutes (Whisper model downloads ~250MB)
+- Watch the **Build logs** tab for progress
+
+---
+
+#### 4. Verify it's running
+
+- Open the Space URL
+- You should see the Sign In / Create Account screen
+- Create an account, add some tasks, and test the AI features
+
+---
+
+## Running Locally
+
+```bash
+# Clone / download the project
+cd second_brain
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set your Groq API key
+export GROQ_API_KEY="gsk_your_key_here"
+
+# Run
+python app.py
+```
+
+Open `http://localhost:7860` in your browser.
+
+---
+
+## Notes
+
+- **Database**: SQLite file `second_brain.db` is created automatically on first run in the app's working directory
+- **Voice transcription**: Uses OpenAI Whisper `small` model (~250MB), downloaded on first voice task
+- **AI model**: Groq `llama-3.3-70b-versatile` (free tier, ~0.3s response time)
+- **Persistence on HF Spaces**: HuggingFace Spaces have ephemeral storage — the SQLite DB resets on each restart. For permanent storage, upgrade to a paid Space with persistent storage, or swap `database.py` to use an external DB (Supabase, PlanetScale, etc.)

ai_engine.py

@@ -0,0 +1,418 @@
+"""
+core/ai_engine.py
+All Groq API calls — prompts taken verbatim from the tested Colab notebook.
+Covers: task parsing, scheduling, journaling Q&A, context synthesis.
+"""
+
+import json
+import re
+import os
+from datetime import datetime, date
+from copy import deepcopy
+
+from groq import Groq
+
+GROQ_MODEL = "llama-3.3-70b-versatile"
+_client: Groq = None
+
+
+def init_groq(api_key: str = None):
+    global _client
+    key = api_key or os.environ.get("GROQ_API_KEY", "")
+    if not key:
+        raise ValueError(
+            "GROQ_API_KEY is not set. "
+            "Add it in HuggingFace Space → Settings → Repository secrets."
+        )
+    _client = Groq(api_key=key)
+
+
+def _groq() -> Groq:
+    if _client is None:
+        init_groq()
+    return _client
+
+
+# ── Shared util ───────────────────────────────────────────────────────────────
+
+def safe_json_parse(text: str):
+    """Parse JSON, stripping markdown fences if present. Returns None on failure."""
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        cleaned = re.sub(r'^```(?:json)?\s*|\s*```$', '', text, flags=re.MULTILINE).strip()
+        try:
+            return json.loads(cleaned)
+        except json.JSONDecodeError:
+            m = re.search(r'\{[\s\S]*\}', cleaned)
+            if m:
+                try:
+                    return json.loads(m.group())
+                except Exception:
+                    pass
+    return None
+
+
+# ── Module 1: Task Capture ────────────────────────────────────────────────────
+
+TASK_CAPTURE_PROMPT = """You are a task classification assistant for a productivity app called The Second Brain.
+
+Your job is to take a user's raw task description and return a structured JSON object.
+
+Classify the task across these dimensions:
+
+1. title (string): A clean, concise, action-oriented task title. Fix grammar.
+
+2. life_area (string): Choose ONE from: Work, Health, Learning, Finance, Personal, Family, Other
+   - Work: job, meetings, deadlines, clients, projects
+   - Health: exercise, medical, diet, mental health
+   - Learning: courses, books, skills, studying
+   - Finance: bills, payments, budgeting, taxes, investments
+   - Personal: hobbies, errands, home maintenance
+   - Family: tasks involving family members
+   - Other: does not fit any category
+
+3. urgency (string): Choose ONE from:
+   - Habit: recurring or routine task
+   - Urgent: hard deadline or time pressure
+   - Not Urgent: no specific deadline
+
+4. importance (string): Choose ONE from:
+   - Move the Needle: very high impact
+   - Important: meaningful, should be done
+   - Not Important: low real impact
+
+5. state_of_mind (string): Choose ONE from:
+   - Quick: 5-10 mins, very low focus
+   - Easy: 10-20 mins, low focus
+   - Flow: deep concentration needed
+   - Personal: life admin, little goal impact
+
+6. time_estimate (integer): Realistic minutes to complete.
+
+7. clarifications_needed (array of strings):
+   If NOT confident about a dimension, add a short specific question.
+   If everything is clear, return []
+
+STRICT RULES:
+- Return ONLY valid JSON. No markdown, no explanation.
+- Never guess if uncertain — ask a clarification question instead.
+- Always return all 7 fields.
+
+Example: {"title": "Finish project proposal", "life_area": "Work", "urgency": "Urgent", "importance": "Move the Needle", "state_of_mind": "Flow", "time_estimate": 90, "clarifications_needed": []}"""
+
+
+def parse_task_with_groq(raw_text: str, user_context: dict = None,
+                         user_goals: list = None, life_areas: list = None) -> dict:
+    """Parse raw task text into structured dimensions using Groq."""
+    # Build context hint from AI memory + goals
+    context_hint = ""
+    if user_context and user_context.get("learned_patterns", {}).get("notes"):
+        notes = user_context["learned_patterns"]["notes"]
+        context_hint += f"\n\nUser context notes (use to inform classification): {'; '.join(notes[-3:])}"
+    if user_goals:
+        context_hint += f"\nUser goals: {'; '.join(user_goals[:5])}"
+    if life_areas:
+        context_hint += f"\nUser's life areas: {', '.join(life_areas)}"
+
+    response = _groq().chat.completions.create(
+        model=GROQ_MODEL,
+        messages=[
+            {"role": "system", "content": TASK_CAPTURE_PROMPT + context_hint},
+            {"role": "user",   "content": f"Parse this task: {raw_text}"}
+        ],
+        max_tokens=512,
+        temperature=0.1,
+    )
+
+    result = safe_json_parse(response.choices[0].message.content.strip())
+    if result is None:
+        result = {
+            "title": raw_text,
+            "life_area": None, "urgency": None, "importance": None,
+            "state_of_mind": None, "time_estimate": None,
+            "clarifications_needed": [
+                "Could you give more details about this task?",
+                "Which area of your life does this belong to?",
+                "Is this urgent or flexible?"
+            ]
+        }
+    return result
+
+
+# ── Module 2: Scheduling ──────────────────────────────────────────────────────
+
+SCHEDULING_SYSTEM_PROMPT = """You are an intelligent daily scheduler for a productivity app called The Second Brain.
+
+You receive a USER CONTEXT (preferences + learned patterns), a TASK LIST, and a SCHEDULING PROMPT.
+Return a time-blocked schedule as a JSON object.
+
+SCHEDULING RULES:
+- Respect wake_time and sleep_time from context
+- Place Flow tasks during the user's peak focus time
+- If avg_task_overrun_pct > 0, add buffer proportionally to time estimates
+- If flow_batch_capable is true, group Flow tasks; otherwise space them out
+- Place Quick and Easy tasks around transitions and low-energy windows
+- Place Personal/Habit tasks at day boundaries (start or end of day)
+- Urgent tasks are scheduled before Not Urgent ones
+- Move the Needle tasks get the best time slots
+- Add 5-10 min breaks between tasks
+- Respect any fixed commitments mentioned in the scheduling prompt
+- Do NOT schedule past sleep_time
+- If tasks won't realistically fit, put them in deferred_tasks
+- If context is minimal (new user), use sensible defaults
+
+RETURN FORMAT (JSON only, no markdown):
+{
+  "schedule_date": "YYYY-MM-DD",
+  "scheduled_tasks": [
+    {
+      "task_id": "(id from input or index)",
+      "title": "...",
+      "life_area": "...",
+      "start_time": "HH:MM",
+      "end_time": "HH:MM",
+      "duration_minutes": 60,
+      "state_of_mind": "...",
+      "scheduling_reason": "1-sentence explanation"
+    }
+  ],
+  "deferred_tasks": [{"task_id": "...", "title": "...", "reason": "..."}],
+  "day_summary": "2-3 sentences on day structure and reasoning",
+  "warnings": ["any concerns e.g. day overloaded"]
+}"""
+
+
+def generate_schedule(context: dict, tasks: list, scheduling_prompt: str,
+                      goals: list = None, schedule_date: str = None) -> dict:
+    if not schedule_date:
+        schedule_date = str(date.today())
+
+    goals_section = ""
+    if goals:
+        goals_section = "\nUSER GOALS:\n" + "\n".join(f"- {g}" for g in goals)
+
+    user_message = f"""Schedule Date: {schedule_date}
+
+USER CONTEXT:
+{json.dumps(context, indent=2)}
+{goals_section}
+TASKS TO SCHEDULE ({len(tasks)} tasks):
+{json.dumps(tasks, indent=2)}
+
+USER SCHEDULING PROMPT:
+{scheduling_prompt}
+
+Generate the optimal schedule."""
+
+    response = _groq().chat.completions.create(
+        model=GROQ_MODEL,
+        messages=[
+            {"role": "system", "content": SCHEDULING_SYSTEM_PROMPT},
+            {"role": "user",   "content": user_message}
+        ],
+        max_tokens=2048,
+        temperature=0.2,
+    )
+
+    result = safe_json_parse(response.choices[0].message.content.strip())
+    if result is None:
+        result = {
+            "error": "Could not parse schedule response.",
+            "raw": response.choices[0].message.content
+        }
+
+    result["schedule_date"] = schedule_date
+    result["generated_at"] = datetime.now().isoformat()
+    return result
+
+
+# ── Module 3: Journaling ──────────────────────────────────────────────────────
+
+JOURNAL_QUESTION_PROMPT = """You are a reflective journaling coach for a productivity app called The Second Brain.
+
+You receive the user's context, today's schedule with completion status, and the conversation so far.
+Your job: decide what targeted question to ask NEXT.
+
+FOCUS AREAS (cover what's most relevant, don't ask all):
+- Tasks not completed — why? wrong time? too tired? overestimated?
+- Tasks that took much longer than estimated
+- Energy levels — when were they sharp vs drained?
+- Whether Flow tasks were placed well or hard to start
+- Whether the day felt balanced or overloaded
+- Patterns the user noticed about themselves
+
+RULES:
+- Ask ONE question at a time. Short and specific.
+- Build on previous answers — don't repeat covered ground.
+- After 4-6 good exchanges, signal completion.
+- Keep tone warm and efficient — 2-minute check-in, not therapy.
+
+RETURN FORMAT (JSON only):
+{"question": "Your next question", "question_focus": "what aspect this targets", "session_complete": false}
+OR when done:
+{"question": null, "question_focus": null, "session_complete": true}"""
+
+
+SYNTHESIS_PROMPT = """You are a pattern recognition engine for a productivity app called The Second Brain.
+
+You have a completed journaling conversation. Extract learnings and return the UPDATED user context JSON.
+
+UPDATE these fields in learned_patterns based on conversation evidence:
+- productive_times: when user felt sharp/focused
+- low_energy_times: when they felt drained or skipped tasks
+- avg_task_overrun_pct: recalculate from actual vs estimated times mentioned
+- flow_batch_capable: update if user gave clear evidence
+- best_life_areas_morning: what they completed well before noon
+- common_skipped_task_types: patterns in what gets consistently skipped
+- notes: append 1-2 new insight notes (keep existing ones)
+
+ALWAYS UPDATE:
+- scheduling_feedback.total_days_scheduled: +1
+- scheduling_feedback.avg_completion_rate: rolling average
+- scheduling_feedback.last_7_day_completion_rates: append today, keep last 7
+- history_summary: append brief today summary, keep last 14
+- last_updated: now
+- version: +1
+
+RULES:
+- Return ONLY the complete updated context JSON. Nothing else.
+- Never remove existing patterns — only update or append.
+- Be conservative — only update if there is clear evidence in the conversation."""
+
+
+def build_opening_question(context: dict, tasks_today: list) -> dict:
+    """Generate the first journal question based on task completion at a glance."""
+    total     = len(tasks_today)
+    completed = sum(1 for t in tasks_today if t.get("completed", False))
+    incomplete = [t for t in tasks_today if not t.get("completed", False)]
+
+    if total == 0:
+        q = "It looks like you didn't have any tasks scheduled today — was that intentional or did things go sideways?"
+    elif completed == 0:
+        q = f"None of today's {total} tasks got marked complete — was the day unexpectedly derailed, or did the plan just not fit how your day went?"
+    elif completed == total:
+        q = f"You completed all {total} tasks today — great day! Did the schedule feel natural, or were you pushing through?"
+    elif len(incomplete) == 1:
+        q = f'You got almost everything done — the one task left was "{incomplete[0]["title"]}". What got in the way?'
+    else:
+        rate   = round(completed / total * 100)
+        titles = ", ".join(f'"{t["title"]}"' for t in incomplete[:2])
+        q = f"You completed {completed}/{total} tasks ({rate}%). Tasks like {titles} didn't get done — was that time, energy, or something else?"
+
+    return {"question": q, "question_focus": "completion_overview", "session_complete": False}
+
+
+def get_next_journal_question(context: dict, tasks_today: list,
+                              conversation_history: list) -> dict:
+    user_message = f"""USER CONTEXT:
+{json.dumps(context, indent=2)}
+
+TODAY'S SCHEDULE (with completion):
+{json.dumps(tasks_today, indent=2)}
+
+CONVERSATION SO FAR ({len(conversation_history)} exchanges):
+{json.dumps(conversation_history, indent=2)}
+
+What should I ask next? Return session_complete: true if enough has been covered."""
+
+    response = _groq().chat.completions.create(
+        model=GROQ_MODEL,
+        messages=[
+            {"role": "system", "content": JOURNAL_QUESTION_PROMPT},
+            {"role": "user",   "content": user_message}
+        ],
+        max_tokens=256,
+        temperature=0.3,
+    )
+
+    result = safe_json_parse(response.choices[0].message.content.strip())
+    if result is None:
+        result = {
+            "question": response.choices[0].message.content.strip(),
+            "question_focus": "general",
+            "session_complete": False
+        }
+    return result
+
+
+def synthesize_journal(context: dict, tasks_today: list,
+                       conversation_history: list) -> dict:
+    """Synthesize conversation into updated context. Fallback to manual stats update if LLM fails."""
+    total     = len(tasks_today)
+    completed = sum(1 for t in tasks_today if t.get("completed", False))
+    completion_rate = round(completed / total, 2) if total > 0 else 0.0
+
+    user_message = f"""USER CONTEXT (current):
+{json.dumps(context, indent=2)}
+
+TODAY'S SCHEDULE + COMPLETION:
+{json.dumps(tasks_today, indent=2)}
+
+Today's completion rate: {completion_rate} ({completed}/{total})
+
+FULL JOURNALING CONVERSATION:
+{json.dumps(conversation_history, indent=2)}
+
+Return the complete updated context JSON."""
+
+    response = _groq().chat.completions.create(
+        model=GROQ_MODEL,
+        messages=[
+            {"role": "system", "content": SYNTHESIS_PROMPT},
+            {"role": "user",   "content": user_message}
+        ],
+        max_tokens=2048,
+        temperature=0.1,
+    )
+
+    updated = safe_json_parse(response.choices[0].message.content.strip())
+
+    if updated is None:
+        # Fallback: update stats manually if synthesis fails
+        updated = deepcopy(context)
+        updated["last_updated"] = datetime.now().isoformat()
+        updated["version"]      = context.get("version", 1) + 1
+        sf    = updated.setdefault("scheduling_feedback", {})
+        sf["total_days_scheduled"] = sf.get("total_days_scheduled", 0) + 1
+        rates = sf.get("last_7_day_completion_rates", [])
+        rates.append(completion_rate)
+        sf["last_7_day_completion_rates"] = rates[-7:]
+        sf["avg_completion_rate"] = round(sum(rates) / len(rates), 2)
+
+    return updated
+
+
+# ── Context helpers ───────────────────────────────────────────────────────────
+
+def create_blank_context(user_id, preferences: dict = None) -> dict:
+    prefs = preferences or {}
+    return {
+        "user_id": user_id,
+        "created_at":   datetime.now().isoformat(),
+        "last_updated": datetime.now().isoformat(),
+        "version": 1,
+        "preferences": {
+            "wake_time":              prefs.get("wake_time", "08:00"),
+            "sleep_time":             prefs.get("sleep_time", "23:00"),
+            "focus_peak":             prefs.get("focus_peak", "Morning"),
+            "break_duration_minutes": 10,
+            "max_flow_block_minutes": 90,
+        },
+        "learned_patterns": {
+            "productive_times":          [],
+            "low_energy_times":          [],
+            "avg_task_overrun_pct":      0,
+            "flow_batch_capable":        None,
+            "best_life_areas_morning":   [],
+            "habit_completion_rate":     {},
+            "common_skipped_task_types": [],
+            "notes":                     []
+        },
+        "history_summary": [],
+        "scheduling_feedback": {
+            "total_days_scheduled":        0,
+            "avg_completion_rate":         0.0,
+            "last_7_day_completion_rates": []
+        }
+    }

app.py

@@ -0,0 +1,1086 @@
+"""
+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,
+    get_life_areas, get_life_area_names, add_life_area, delete_life_area,
+    get_tasks, save_task, toggle_task_complete, delete_task, get_today_stats,
+    load_user_context, save_user_context, spawn_due_habits,
+)
+from core.ai_engine import (
+    init_groq, create_blank_context,
+    parse_task_with_groq, generate_schedule,
+    build_opening_question, get_next_journal_question, synthesize_journal,
+)
+from core.styles import CSS
+
+# ── Boot ──────────────────────────────────────────────────────────────────────
+init_db()
+init_groq()                         # reads GROQ_API_KEY from env
+
+TASK_HEADERS = ["ID", "Done", "Title", "Area", "Urgency", "Importance", "Mind", "Min", "Date"]
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# SHARED HELPERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def _ok(msg):   return f'<span style="color:#4ade80;font-size:13px">✓ {msg}</span>'
+def _err(msg):  return f'<span style="color:#f87171;font-size:13px">⚠ {msg}</span>'
+def _info(msg): return f'<span style="color:#60a5fa;font-size:13px">ℹ {msg}</span>'
+
+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 _area_choices(user_id):
+    if not user_id:
+        return ["All"]
+    return ["All"] + get_life_area_names(user_id)
+
+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
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# AUTH HANDLERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def handle_login(username, password):
+    uid, msg = login_user(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)
+
+
+def handle_register(username, password, wake, sleep, focus, goals_text):
+    uid, msg = register_user(username, password)
+    if not uid:
+        return None, "", _err(msg), gr.update(visible=True), gr.update(visible=False)
+    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)
+    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)
+
+
+def handle_logout(user_id):
+    return None, "", gr.update(visible=True), gr.update(visible=False)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TODAY TAB HANDLERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def refresh_today(user_id):
+    if not user_id:
+        return [], _stat("—","Today","#a78bfa"), _stat("—","Done","#4ade80"), _stat("—","Left","#f87171")
+    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)
+
+def hide_panels():
+    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+
+
+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", "")
+
+    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 = ""
+    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"),
+    )
+
+
+def handle_transcribe_voice(audio_path, user_id):
+    """Whisper transcription then Groq parse — same pipeline as notebook."""
+    if audio_path is None:
+        return gr.update(visible=False), _err("No audio recorded.")
+    try:
+        import whisper
+        global _whisper_model
+        if _whisper_model is None:
+            _whisper_model = whisper.load_model("small")
+        result = _whisper_model.transcribe(audio_path)
+        text   = result["text"].strip()
+        return gr.update(visible=True, value=text), _ok(f'Transcribed: "{text[:60]}..."')
+    except Exception as e:
+        return gr.update(visible=False), _err(f"Transcription error: {e}")
+
+_whisper_model = None
+
+
+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)
+    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.")
+    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 "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>'
+    )
+
+    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>'
+        )
+
+    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>'
+        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)
+    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)
+    rows, s1, s2, s3 = refresh_today(user_id)
+    return rows, s1, s2, s3, _ok("Deleted")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ALL TASKS TAB HANDLERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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))
+
+
+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)
+    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)
+    return refresh_all_tasks(user_id, filter_area, only_today), _ok("Deleted")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# JOURNAL TAB HANDLERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def handle_load_journal_tasks(user_id):
+    if not user_id:
+        return "<p style='color:#f87171'>Not logged in.</p>", gr.update(visible=False), []
+
+    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)
+    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"]}]
+
+    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, "", ""
+
+
+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 (
+        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>'
+    )
+
+
+def handle_restart_journal():
+    return [], [], False, gr.update(interactive=False), gr.update(interactive=False), ""
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# LIFE AREAS & GOALS HANDLERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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]
+    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=""),
+    )
+
+
+def handle_del_area(user_id, name):
+    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),
+    )
+
+
+def handle_save_goals(user_id, goals_text):
+    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))
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PREFERENCES HANDLERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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),
+    )
+
+
+def handle_save_prefs(user_id, wake, sleep, focus, brk, flow_max):
+    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),
+    })
+    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>"
+    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 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>'
+
+    return html
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# UI BUILD
+# ═══════════════════════════════════════════════════════════════════════════════
+
+with gr.Blocks(css=CSS, title="🧠 Second Brain") as demo:
+
+    # ── Session state ──────────────────────────────────────────────────────────
+    user_id_state   = gr.State(None)
+    username_state  = gr.State("")
+    # Journal states
+    journal_chat_state  = gr.State([])
+    journal_hist_state  = gr.State([])
+    journal_tasks_state = gr.State([])
+    journal_active      = gr.State(False)
+
+    # ═════════════════════════════════════════════════════════════════════════
+    # AUTH SECTION
+    # ═════════════════════════════════════════════════════════════════════════
+    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="••••••••")
+                with gr.Row():
+                    reg_wake  = gr.Textbox(label="Wake time",  value="07:30", scale=1)
+                    reg_sleep = gr.Textbox(label="Sleep time", value="23:00", scale=1)
+                    reg_focus = gr.Dropdown(label="Peak focus",
+                                            choices=["Morning","Afternoon","Evening","Night"],
+                                            value="Morning", scale=1)
+                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
+    # ═════════════════════════════════════════════════════════════════════════
+    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:
+
+            # ─────────────────────────────────────────────────────────────
+            # 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 ────────────────────────────────────────
+                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
+                    )
+                    with gr.Row():
+                        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("")
+                        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)
+                        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")
+                        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_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)
+                        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 ───────────────────────────────────────
+                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)
+                    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("")
+
+                # ── 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
+                    )
+                    with gr.Row():
+                        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)
+                    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
+            # ─────────────────────────────────────────────────────────────
+            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)
+                    btn_all_done = gr.Button("✅ Done",   elem_classes="btn-success", scale=2)
+                    all_del_id   = gr.Number(label="Task ID — delete",      precision=0, scale=2)
+                    btn_all_del  = gr.Button("🗑 Delete", elem_classes="btn-danger",  scale=2)
+                all_action_msg = gr.HTML("")
+
+            # ─────────────────────────────────────────────────────────────
+            # 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, bubble_full_width=False)
+                    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
+            # ─────────────────────────────────────────────────────────────
+            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
+            # ─────────────────────────────────────────────────────────────
+            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)
+                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")
+
+
+    # ═══════════════════════════════════════════════════════════════════════
+    # EVENT WIRING
+    # ══════════════════��════════════════════════════════════════════════════
+
+    # ── Auth ──────────────────────────────────────────────────────────────
+
+    def _post_login(uid, uname):
+        if not uid:
+            return uid, uname
+        spawn_due_habits(uid)
+        return uid, uname
+
+    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]
+    )
+
+    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]
+    )
+
+    # ── Today tab ─────────────────────────────────────────────────────────
+
+    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]
+    )
+
+    # Show habit interval dropdown only when habit checked
+    f_is_habit.change(
+        lambda v: gr.update(visible=v),
+        [f_is_habit], [f_interval]
+    )
+
+    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]
+    )
+
+    btn_transcribe.click(
+        handle_transcribe_voice,
+        [audio_input, user_id_state],
+        [transcribed, voice_msg]
+    )
+
+    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],
+        [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 ────────────────────────────────────────────────────────
+
+    btn_load_tasks.click(
+        handle_load_journal_tasks,
+        [user_id_state],
+        [journal_task_list, journal_mark_row, journal_tasks_state]
+    )
+
+    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_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]
+    )
+
+    # ── Areas & Goals tab ─────────────────────────────────────────────────
+
+    btn_add_area.click(
+        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]
+    )
+
+    btn_del_area.click(
+        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]
+    )
+
+    btn_save_goals.click(
+        handle_save_goals,
+        [user_id_state, goals_input],
+        [goals_msg]
+    )
+
+    # ── Preferences tab ───────────────────────────────────────────────────
+
+    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)
+
+
+# ── Launch ─────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

database.py

@@ -0,0 +1,386 @@
+"""
+core/database.py
+SQLite persistence for Second Brain.
+Tables: users, life_areas, goals, tasks, user_context (AI memory)
+"""
+
+import sqlite3
+import json
+import bcrypt
+from datetime import datetime, date
+from typing import Optional
+
+DB_PATH = "second_brain.db"
+
+
+# ── Connection ────────────────────────────────────────────────────────────────
+
+def get_db() -> sqlite3.Connection:
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    return conn
+
+
+def init_db():
+    """Create all tables on first run."""
+    conn = get_db()
+    c = conn.cursor()
+
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS users (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            username      TEXT UNIQUE NOT NULL,
+            password_hash TEXT NOT NULL,
+            created_at    TEXT DEFAULT (datetime('now'))
+        )
+    """)
+
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS life_areas (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id    INTEGER NOT NULL,
+            name       TEXT NOT NULL,
+            color      TEXT DEFAULT '#6366f1',
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (user_id) REFERENCES users(id)
+        )
+    """)
+
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS user_goals (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id    INTEGER NOT NULL,
+            goal_text  TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (user_id) REFERENCES users(id)
+        )
+    """)
+
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS tasks (
+            id              INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id         INTEGER NOT NULL,
+            title           TEXT NOT NULL,
+            life_area       TEXT DEFAULT '',
+            urgency         TEXT DEFAULT 'Not Urgent',
+            importance      TEXT DEFAULT 'Important',
+            state_of_mind   TEXT DEFAULT 'Easy',
+            time_estimate   INTEGER DEFAULT 30,
+            scheduled_date  TEXT DEFAULT (date('now')),
+            is_completed    INTEGER DEFAULT 0,
+            actual_duration INTEGER,
+            is_habit        INTEGER DEFAULT 0,
+            habit_interval  TEXT DEFAULT '',
+            raw_input       TEXT DEFAULT '',
+            created_at      TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (user_id) REFERENCES users(id)
+        )
+    """)
+
+    # AI-learned context stored as a JSON blob per user
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS user_context (
+            user_id    INTEGER PRIMARY KEY,
+            context    TEXT NOT NULL,
+            updated_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (user_id) REFERENCES users(id)
+        )
+    """)
+
+    conn.commit()
+    conn.close()
+
+
+# ── Auth ──────────────────────────────────────────────────────────────────────
+
+def register_user(username: str, password: str) -> tuple:
+    """Returns (user_id, message). user_id is None on failure."""
+    username = username.strip().lower()
+    if not username or not password:
+        return None, "Username and password cannot be empty."
+    if len(password) < 6:
+        return None, "Password must be at least 6 characters."
+    conn = get_db()
+    try:
+        pw_hash = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+        conn.execute(
+            "INSERT INTO users (username, password_hash) VALUES (?, ?)",
+            (username, pw_hash)
+        )
+        conn.commit()
+        row = conn.execute("SELECT id FROM users WHERE username = ?", (username,)).fetchone()
+        return row["id"], "Account created!"
+    except sqlite3.IntegrityError:
+        return None, "Username already taken."
+    finally:
+        conn.close()
+
+
+def login_user(username: str, password: str) -> tuple:
+    """Returns (user_id, message). user_id is None on failure."""
+    username = username.strip().lower()
+    if not username or not password:
+        return None, "Please enter your credentials."
+    conn = get_db()
+    row = conn.execute(
+        "SELECT id, password_hash FROM users WHERE username = ?", (username,)
+    ).fetchone()
+    conn.close()
+    if not row:
+        return None, "Username not found."
+    if not bcrypt.checkpw(password.encode(), row["password_hash"].encode()):
+        return None, "Incorrect password."
+    return row["id"], f"Welcome back, {username}!"
+
+
+def get_username(user_id: int) -> str:
+    conn = get_db()
+    row = conn.execute("SELECT username FROM users WHERE id = ?", (user_id,)).fetchone()
+    conn.close()
+    return row["username"].capitalize() if row else "User"
+
+
+# ── Life Areas ────────────────────────────────────────────────────────────────
+
+DEFAULT_AREAS = [
+    ("Work",     "#4F8EF7"),
+    ("Health",   "#4CAF87"),
+    ("Finance",  "#F7A84F"),
+    ("Learning", "#A855F7"),
+    ("Personal", "#EC4899"),
+    ("Family",   "#F59E0B"),
+]
+
+
+def create_default_life_areas(user_id: int):
+    conn = get_db()
+    for name, color in DEFAULT_AREAS:
+        conn.execute(
+            "INSERT INTO life_areas (user_id, name, color) VALUES (?, ?, ?)",
+            (user_id, name, color)
+        )
+    conn.commit()
+    conn.close()
+
+
+def get_life_areas(user_id: int) -> list:
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT id, name, color FROM life_areas WHERE user_id = ? ORDER BY id",
+        (user_id,)
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def get_life_area_names(user_id: int) -> list:
+    return [a["name"] for a in get_life_areas(user_id)]
+
+
+def add_life_area(user_id: int, name: str, color: str = "#6366f1") -> tuple:
+    name = name.strip()
+    if not name:
+        return False, "Name cannot be empty."
+    conn = get_db()
+    exists = conn.execute(
+        "SELECT id FROM life_areas WHERE user_id = ? AND LOWER(name) = LOWER(?)",
+        (user_id, name)
+    ).fetchone()
+    if exists:
+        conn.close()
+        return False, f'"{name}" already exists.'
+    conn.execute(
+        "INSERT INTO life_areas (user_id, name, color) VALUES (?, ?, ?)",
+        (user_id, name, color)
+    )
+    conn.commit()
+    conn.close()
+    return True, f'"{name}" added.'
+
+
+def delete_life_area(user_id: int, name: str) -> tuple:
+    conn = get_db()
+    conn.execute(
+        "DELETE FROM life_areas WHERE user_id = ? AND name = ?", (user_id, name)
+    )
+    conn.commit()
+    conn.close()
+    return True, f'"{name}" removed.'
+
+
+# ── Goals ─────────────────────────────────────────────────────────────────────
+
+def save_goals(user_id: int, goals_text: str):
+    conn = get_db()
+    conn.execute("DELETE FROM user_goals WHERE user_id = ?", (user_id,))
+    for line in goals_text.strip().splitlines():
+        line = line.strip("•- ").strip()
+        if line:
+            conn.execute(
+                "INSERT INTO user_goals (user_id, goal_text) VALUES (?, ?)",
+                (user_id, line)
+            )
+    conn.commit()
+    conn.close()
+
+
+def get_goals(user_id: int) -> list:
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT goal_text FROM user_goals WHERE user_id = ? ORDER BY id",
+        (user_id,)
+    ).fetchall()
+    conn.close()
+    return [r["goal_text"] for r in rows]
+
+
+# ── Tasks ─────────────────────────────────────────────────────────────────────
+
+def save_task(user_id: int, task: dict, scheduled_date: str = None) -> int:
+    conn = get_db()
+    cursor = conn.execute("""
+        INSERT INTO tasks
+            (user_id, title, life_area, urgency, importance, state_of_mind,
+             time_estimate, scheduled_date, raw_input, is_habit, habit_interval)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (
+        user_id,
+        task.get("title", "Untitled"),
+        task.get("life_area", ""),
+        task.get("urgency", "Not Urgent"),
+        task.get("importance", "Important"),
+        task.get("state_of_mind", "Easy"),
+        int(task.get("time_estimate") or 30),
+        scheduled_date or str(date.today()),
+        task.get("raw_input", ""),
+        1 if task.get("is_habit") else 0,
+        task.get("habit_interval", ""),
+    ))
+    task_id = cursor.lastrowid
+    conn.commit()
+    conn.close()
+    return task_id
+
+
+def get_tasks(user_id: int, filter_area: str = "All", only_today: bool = False,
+              include_completed: bool = True) -> list:
+    conn = get_db()
+    q = "SELECT * FROM tasks WHERE user_id = ?"
+    params = [user_id]
+    if filter_area and filter_area != "All":
+        q += " AND life_area = ?"
+        params.append(filter_area)
+    if only_today:
+        q += " AND scheduled_date = ?"
+        params.append(str(date.today()))
+    if not include_completed:
+        q += " AND is_completed = 0"
+    q += " ORDER BY is_completed ASC, created_at DESC"
+    rows = conn.execute(q, params).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def toggle_task_complete(task_id: int, user_id: int, actual_duration: int = None):
+    conn = get_db()
+    task = conn.execute(
+        "SELECT is_completed FROM tasks WHERE id = ? AND user_id = ?", (task_id, user_id)
+    ).fetchone()
+    if task:
+        new_status = 1 - task["is_completed"]
+        if actual_duration and new_status == 1:
+            conn.execute(
+                "UPDATE tasks SET is_completed = ?, actual_duration = ? WHERE id = ? AND user_id = ?",
+                (new_status, actual_duration, task_id, user_id)
+            )
+        else:
+            conn.execute(
+                "UPDATE tasks SET is_completed = ? WHERE id = ? AND user_id = ?",
+                (new_status, task_id, user_id)
+            )
+    conn.commit()
+    conn.close()
+
+
+def delete_task(task_id: int, user_id: int):
+    conn = get_db()
+    conn.execute("DELETE FROM tasks WHERE id = ? AND user_id = ?", (task_id, user_id))
+    conn.commit()
+    conn.close()
+
+
+def get_today_stats(user_id: int) -> dict:
+    tasks = get_tasks(user_id, only_today=True)
+    total = len(tasks)
+    done  = sum(1 for t in tasks if t["is_completed"])
+    return {"total": total, "done": done, "remaining": total - done}
+
+
+# ── Habit recurrence ──────────────────────────────────────────────────────────
+
+def spawn_due_habits(user_id: int):
+    """
+    Check all habit tasks. If a habit's scheduled_date < today and
+    it's not already scheduled for today, create a fresh copy for today.
+    Called on login / tab load.
+    """
+    today = str(date.today())
+    conn = get_db()
+    habits = conn.execute(
+        "SELECT * FROM tasks WHERE user_id = ? AND is_habit = 1",
+        (user_id,)
+    ).fetchall()
+
+    for h in habits:
+        # Check if already exists today
+        existing = conn.execute(
+            "SELECT id FROM tasks WHERE user_id = ? AND title = ? AND is_habit = 1 AND scheduled_date = ?",
+            (user_id, h["title"], today)
+        ).fetchone()
+        if existing:
+            continue
+        # Only spawn if original was scheduled before today
+        if h["scheduled_date"] and h["scheduled_date"] >= today:
+            continue
+        conn.execute("""
+            INSERT INTO tasks (user_id, title, life_area, urgency, importance,
+                               state_of_mind, time_estimate, scheduled_date, is_habit,
+                               habit_interval, raw_input)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+        """, (
+            user_id, h["title"], h["life_area"], "Habit",
+            h["importance"], h["state_of_mind"], h["time_estimate"],
+            today, h["habit_interval"], h["raw_input"]
+        ))
+    conn.commit()
+    conn.close()
+
+
+# ── AI Context ────────────────────────────────────────────────────────────────
+
+def load_user_context(user_id: int) -> Optional[dict]:
+    conn = get_db()
+    row = conn.execute(
+        "SELECT context FROM user_context WHERE user_id = ?", (user_id,)
+    ).fetchone()
+    conn.close()
+    if row:
+        try:
+            return json.loads(row["context"])
+        except Exception:
+            return None
+    return None
+
+
+def save_user_context(user_id: int, context: dict):
+    conn = get_db()
+    conn.execute("""
+        INSERT INTO user_context (user_id, context, updated_at)
+        VALUES (?, ?, datetime('now'))
+        ON CONFLICT(user_id) DO UPDATE SET
+            context    = excluded.context,
+            updated_at = excluded.updated_at
+    """, (user_id, json.dumps(context)))
+    conn.commit()
+    conn.close()

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.20.0
+groq>=0.4.0
+openai-whisper>=20231117
+bcrypt>=4.0.0
+python-multipart>=0.0.9

styles.py

@@ -0,0 +1,190 @@
+"""
+core/styles.py
+All CSS for the Second Brain Gradio app.
+"""
+
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Sora:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap');
+
+/* ── Reset & base ──────────────────────────────────────── */
+*, *::before, *::after { box-sizing: border-box; }
+
+body, .gradio-container {
+    font-family: 'Sora', system-ui, sans-serif !important;
+    background: #060a12 !important;
+    color: #cbd5e1 !important;
+}
+.gradio-container { max-width: 1200px !important; margin: 0 auto !important; }
+.main { padding: 16px !important; }
+
+/* ── Auth card ─────────────────────────────────────────── */
+#auth-card {
+    max-width: 420px;
+    margin: 48px auto 0;
+    background: #0d1117;
+    border: 1px solid #1e293b;
+    border-radius: 20px;
+    padding: 40px 36px 32px;
+    box-shadow: 0 0 80px rgba(99,102,241,.1);
+}
+#brand-logo {
+    font-size: 28px; font-weight: 700; text-align: center;
+    background: linear-gradient(135deg, #a78bfa 0%, #60a5fa 100%);
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+    margin-bottom: 4px;
+}
+#brand-sub { text-align: center; color: #334155; font-size: 13px; margin-bottom: 28px; }
+
+/* ── Top header ────────────────────────────────────────── */
+#top-header {
+    background: #0d1117;
+    border: 1px solid #1e293b;
+    border-radius: 14px;
+    padding: 14px 22px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 18px;
+}
+#top-header-brand {
+    font-size: 18px; font-weight: 700;
+    background: linear-gradient(135deg, #a78bfa, #60a5fa);
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+}
+#top-header-user { font-size: 12px; color: #334155; }
+
+/* ── Stat cards ────────────────────────────────────────── */
+.stat-card {
+    background: #0d1117;
+    border: 1px solid #1e293b;
+    border-radius: 14px;
+    padding: 18px 12px;
+    text-align: center;
+    min-height: 90px;
+}
+.stat-num   { font-size: 36px; font-weight: 700; line-height: 1; }
+.stat-label { font-size: 10px; color: #334155; margin-top: 6px;
+              text-transform: uppercase; letter-spacing: .8px; }
+
+/* ── Panels ────────────────────────────────────────────── */
+.panel {
+    background: #0d1117;
+    border: 1px solid #1e293b;
+    border-radius: 14px;
+    padding: 22px 20px;
+    margin-top: 14px;
+}
+.sec-label {
+    font-size: 10px; text-transform: uppercase; letter-spacing: 1.2px;
+    color: #334155; font-weight: 600; margin-bottom: 16px;
+}
+
+/* ── Buttons ───────────────────────────────────────────── */
+.btn-primary button {
+    background: linear-gradient(135deg,#6366f1,#8b5cf6) !important;
+    color: #fff !important; font-weight: 600 !important;
+    border: none !important; border-radius: 10px !important;
+    font-family: 'Sora', sans-serif !important;
+    transition: opacity .15s !important;
+}
+.btn-primary button:hover { opacity: .85 !important; }
+
+.btn-accent button {
+    background: linear-gradient(135deg,#0ea5e9,#6366f1) !important;
+    color: #fff !important; font-weight: 600 !important;
+    border: none !important; border-radius: 10px !important;
+    font-family: 'Sora', sans-serif !important;
+}
+.btn-secondary button {
+    background: #161b27 !important; color: #64748b !important;
+    border: 1px solid #1e293b !important; border-radius: 10px !important;
+    font-family: 'Sora', sans-serif !important;
+}
+.btn-success button {
+    background: #052e16 !important; color: #4ade80 !important;
+    border: 1px solid #14532d !important; border-radius: 10px !important;
+    font-family: 'Sora', sans-serif !important;
+}
+.btn-danger button {
+    background: #1c0606 !important; color: #f87171 !important;
+    border: 1px solid #450a0a !important; border-radius: 10px !important;
+    font-family: 'Sora', sans-serif !important;
+}
+
+/* ── Inputs ────────────────────────────────────────────── */
+input, textarea, select {
+    background: #060a12 !important;
+    border: 1px solid #1e293b !important;
+    border-radius: 10px !important;
+    color: #e2e8f0 !important;
+    font-family: 'Sora', sans-serif !important;
+}
+input:focus, textarea:focus {
+    border-color: #6366f1 !important;
+    box-shadow: 0 0 0 2px rgba(99,102,241,.18) !important;
+}
+label { color: #475569 !important; font-size: 12px !important; font-weight: 500 !important; }
+
+/* ── Tabs ──────────────────────────────────────────────── */
+.tab-nav button {
+    color: #334155 !important; font-family: 'Sora', sans-serif !important;
+    font-weight: 500 !important; background: transparent !important;
+    border: none !important; border-bottom: 2px solid transparent !important;
+    padding: 10px 18px !important; font-size: 13px !important;
+}
+.tab-nav button.selected {
+    color: #a78bfa !important;
+    border-bottom: 2px solid #a78bfa !important;
+}
+
+/* ── Dataframe ─────────────────────────────────────────── */
+.dataframe thead th {
+    background: #0d1117 !important; color: #334155 !important;
+    font-size: 10px !important; text-transform: uppercase !important;
+    letter-spacing: .6px !important; padding: 10px 12px !important;
+    font-family: 'Sora', sans-serif !important; border: none !important;
+}
+.dataframe tbody td {
+    background: #060a12 !important; color: #94a3b8 !important;
+    font-family: 'JetBrains Mono', monospace !important;
+    font-size: 12px !important; padding: 9px 12px !important;
+    border-bottom: 1px solid #0d1117 !important;
+}
+.dataframe tbody tr:hover td { background: #0d1117 !important; }
+
+/* ── Chatbot ───────────────────────────────────────────── */
+.chatbot {
+    background: #060a12 !important;
+    border: 1px solid #1e293b !important;
+    border-radius: 14px !important;
+}
+
+/* ── Schedule cards ────────────────────────────────────── */
+.sched-card {
+    background: #0d1117;
+    border: 1px solid #1e293b;
+    border-left: 3px solid #6366f1;
+    border-radius: 10px;
+    padding: 12px 16px;
+    margin-bottom: 8px;
+}
+.sched-time  { font-size: 11px; font-family: 'JetBrains Mono',monospace; color: #6366f1; font-weight: 600; }
+.sched-title { font-size: 14px; font-weight: 600; color: #f1f5f9; margin: 2px 0 4px; }
+.sched-meta  { font-size: 11px; color: #334155; }
+.sched-why   { font-size: 11px; color: #475569; font-style: italic; margin-top: 3px; }
+
+/* ── Life area chips ───────────────────────────────────── */
+.chip {
+    display: inline-block; padding: 4px 12px; border-radius: 20px;
+    font-size: 12px; font-weight: 600; margin: 3px;
+}
+
+/* ── Status messages ───────────────────────────────────── */
+.ok  { color: #4ade80; font-size: 13px; }
+.err { color: #f87171; font-size: 13px; }
+.inf { color: #60a5fa; font-size: 13px; }
+
+/* ── Misc ──────────────────────────────────────────────── */
+hr { border-color: #1e293b !important; margin: 16px 0 !important; }
+.hidden { display: none !important; }
+"""