feat(journal): conversational LLM-generated daily prep (replaces card)

The structured prep card was data-rich but voiceless. Replaced with an
LLM-generated conversational opener — same shape the briefing's compilation
slot had — that renders as a normal assistant chat bubble at the top of
the day's conversation.

Backend (services/journal_prep.py):
- Renamed generate_daily_prep -> gather_daily_sections (still pure data
  fetching, no LLM); kept the old name as a backwards-compat alias.
- New _generate_prep_prose: hands the gathered sections to generate_completion
  with a warm-conversational system prompt; returns prose. Falls back to a
  plain greeting if the LLM call fails or no model is configured.
- ensure_daily_prep_message now persists the prep as role='assistant' with
  the prose as content. Structured sections stay on msg_metadata for
  provenance. Auto-upgrades legacy system-role preps in place on next call.

Frontend:
- Drop the <article class="daily-prep"> structured block from JournalView.
  The prep is now just the first chat bubble — picks up the existing
  Illuminated Transcript styling automatically.
- Drop dayMessages / prepMessage / prepSections / asArray helpers — no
  longer needed.
- ChatMessage hideMessage filter: comment refined to clarify it only
  catches LEGACY system-role prep rows. Current preps are assistant-role
  and render normally.

Net effect: open /journal -> first thing you see is a warm assistant bubble
that talks about your day -> input bar below to reply.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/fabledassistant/services/journal_prep.py

@@ -1,17 +1,23 @@
 """Daily prep generator for the Journal.
 
 Runs once per day per user (scheduled, or lazy on first journal-open of a
-new day). Gathers raw data into a structured prep block that becomes the
-first message of the day's journal Conversation.
+new day). Two phases:
 
-The output shape lives on Message.msg_metadata as:
-    { kind: 'daily_prep', sections: { tasks, events, weather,
-      projects, recent_moments, open_threads } }
+1. Gather structured data (tasks/events/weather/projects/recent moments/
+   open threads) — deterministic, no LLM call.
+2. Hand the structured data to the LLM and ask it for a warm conversational
+   opener — flowing prose, not a card. The result is persisted as the first
+   *assistant* message in today's journal Conversation, so it renders with
+   the standard Illuminated Transcript bubble styling alongside the rest of
+   the conversation.
 
-Deliberately deterministic — no LLM call here. The journal LLM weaves
-narrative into the conversation later, when the user actually starts
-talking. Generating prose at scheduled-prep time would burn model time
-on something the user may never read.
+The structured data is preserved on ``Message.msg_metadata.sections`` for
+provenance and future tooling, but is NOT visually surfaced as a card.
+
+Message shape:
+    role: 'assistant'
+    content: <prose opener>
+    msg_metadata: { kind: 'daily_prep', sections: { ...raw data... } }
 """
 from __future__ import annotations
 
@@ -20,23 +26,29 @@ import logging
 
 from sqlalchemy import select
 
+from fabledassistant.config import Config
 from fabledassistant.models import Conversation, Message, async_session
 from fabledassistant.services.events import list_events
 from fabledassistant.services.journal_search import search_journal
 from fabledassistant.services.notes import list_notes
 from fabledassistant.services.projects import list_projects
+from fabledassistant.services.settings import get_setting
 from fabledassistant.services.weather import get_cached_weather_rows
 
 logger = logging.getLogger(__name__)
 
 
-async def generate_daily_prep(
+async def gather_daily_sections(
     *,
     user_id: int,
     day_date: datetime.date,
     user_timezone: str,
 ) -> dict:
-    """Gather all daily-prep sections and return them as a dict."""
+    """Gather all daily-prep sections and return them as a dict.
+
+    Pure data fetching — no LLM call. Each section degrades to an empty
+    list/dict on failure so the caller always gets a complete shape.
+    """
     sections: dict = {}
 
     try:
@@ -66,7 +78,6 @@ async def generate_daily_prep(
     try:
         day_start = datetime.datetime.combine(day_date, datetime.time.min)
         day_end = datetime.datetime.combine(day_date, datetime.time.max)
-        # list_events already returns dicts.
         sections["events"] = await list_events(
             user_id=user_id,
             date_from=day_start,
@@ -137,6 +148,156 @@ async def _open_threads(*, user_id: int, day_date: datetime.date) -> list[dict]:
     ]
 
 
+def _render_sections_for_prompt(sections: dict) -> str:
+    """Render the gathered sections as a structured plain-text block for the LLM."""
+    lines: list[str] = []
+
+    tasks = sections.get("tasks") or []
+    if tasks:
+        lines.append("TASKS (todo or in-progress):")
+        for t in tasks[:12]:
+            line = f"  - {t.get('title', '?')}"
+            if t.get("due_date"):
+                line += f" (due {t['due_date']})"
+            if t.get("priority") and t["priority"] not in (None, "none"):
+                line += f" [{t['priority']} priority]"
+            if t.get("status") == "in_progress":
+                line += " [in progress]"
+            lines.append(line)
+        lines.append("")
+
+    events = sections.get("events") or []
+    if events:
+        lines.append("CALENDAR EVENTS TODAY:")
+        for e in events[:8]:
+            title = e.get("title", "Untitled")
+            when = e.get("start_dt", "?")
+            location = e.get("location") or ""
+            line = f"  - {title} at {when}"
+            if location:
+                line += f" ({location})"
+            lines.append(line)
+        lines.append("")
+
+    weather = sections.get("weather") or []
+    if weather:
+        lines.append("WEATHER:")
+        for w in weather:
+            label = w.get("location_label") or w.get("location_key") or "Location"
+            forecast_json = w.get("forecast_json") or {}
+            daily = forecast_json.get("daily") or {}
+            today_max = (daily.get("temperature_2m_max") or [None])[0]
+            today_min = (daily.get("temperature_2m_min") or [None])[0]
+            precip = (daily.get("precipitation_probability_max") or [None])[0]
+            bits = [label]
+            if today_max is not None and today_min is not None:
+                bits.append(f"high {today_max}° / low {today_min}°")
+            if precip is not None:
+                bits.append(f"{precip}% chance of precipitation")
+            lines.append("  - " + ", ".join(bits))
+        lines.append("")
+
+    projects = sections.get("projects") or []
+    if projects:
+        lines.append("ACTIVE PROJECTS:")
+        for p in projects[:5]:
+            line = f"  - {p.get('title', '?')}"
+            if p.get("auto_summary"):
+                summary = p["auto_summary"][:160]
+                line += f" — {summary}"
+            lines.append(line)
+        lines.append("")
+
+    recent_moments = sections.get("recent_moments") or []
+    if recent_moments:
+        lines.append("RECENT JOURNAL MOMENTS (last few days):")
+        for m in recent_moments[:8]:
+            day = m.get("day_date", "?")
+            content = (m.get("content") or "").strip()
+            lines.append(f"  - [{day}] {content}")
+        lines.append("")
+
+    open_threads = sections.get("open_threads") or []
+    if open_threads:
+        lines.append("OPEN THREADS (mentioned recently but not resolved):")
+        for m in open_threads[:5]:
+            day = m.get("day_date", "?")
+            content = (m.get("content") or "").strip()
+            lines.append(f"  - [{day}] {content}")
+        lines.append("")
+
+    if not lines:
+        return "(No data for today — quiet morning.)"
+    return "\n".join(lines).rstrip()
+
+
+_PREP_SYSTEM_PROMPT = (
+    "You are opening the user's daily journal with a warm, conversational greeting. "
+    "Weave the data they're handing you into a flowing prose welcome — like a "
+    "thoughtful friend recapping what's on the user's plate today and gently inviting "
+    "them to journal about it.\n\n"
+    "Rules:\n"
+    "- Write flowing sentences. NO markdown, NO bullet points, NO headers.\n"
+    "- Reference items that genuinely matter; skip categories with no real data.\n"
+    "- If RECENT JOURNAL MOMENTS are present, briefly acknowledge what they were doing, thinking, or feeling.\n"
+    "- If OPEN THREADS are present, gently surface one or two as questions worth revisiting.\n"
+    "- Aim for 5 to 9 sentences. Warm but brief.\n"
+    "- Close with one short open invitation to journal — examples: \"What's on your mind?\", "
+    "\"How are you starting the day?\", \"Anything you want to set down before this kicks off?\"\n"
+    "- Don't fabricate details. If a category is empty, just skip it; don't lie about what's there.\n"
+    "- Don't list things mechanically (\"You have 3 tasks today...\"). Talk like a person."
+)
+
+
+def _fallback_prep_text(day_date: datetime.date) -> str:
+    """If the LLM call fails, return a minimal greeting so the user still sees something."""
+    weekday = day_date.strftime("%A")
+    return f"Good morning. {weekday}, {day_date.isoformat()}. What's on your mind?"
+
+
+async def _generate_prep_prose(
+    *,
+    sections: dict,
+    day_date: datetime.date,
+    user_id: int,
+) -> str:
+    """Ask the LLM for a conversational journal opener built from the sections."""
+    from fabledassistant.services.llm import generate_completion
+
+    model = (await get_setting(user_id, "default_model", "")) or Config.OLLAMA_MODEL
+    if not model:
+        logger.warning("No LLM model configured for daily prep — using fallback text")
+        return _fallback_prep_text(day_date)
+
+    rendered = _render_sections_for_prompt(sections)
+    user_trigger = (
+        f"Today is {day_date.strftime('%A, %B %-d, %Y')} ({day_date.isoformat()}).\n\n"
+        f"Here is what I gathered for you:\n\n{rendered}\n\n"
+        f"Write the opener for today's journal."
+    )
+
+    messages = [
+        {"role": "system", "content": _PREP_SYSTEM_PROMPT},
+        {"role": "user", "content": user_trigger},
+    ]
+
+    try:
+        prose = await generate_completion(
+            messages=messages,
+            model=model,
+            max_tokens=600,
+        )
+    except Exception:
+        logger.exception("Daily prep prose generation failed for day %s", day_date)
+        return _fallback_prep_text(day_date)
+
+    prose = (prose or "").strip()
+    if not prose:
+        logger.warning("LLM returned empty prep prose for day %s — using fallback", day_date)
+        return _fallback_prep_text(day_date)
+    return prose
+
+
 async def ensure_daily_prep_message(
     *,
     user_id: int,
@@ -146,8 +307,13 @@ async def ensure_daily_prep_message(
 ) -> Message:
     """Get or create today's journal Conversation, then ensure the prep message exists.
 
-    With force=True, regenerate even if a prep message already exists today
-    (used by the manual /api/journal/trigger-prep endpoint).
+    The prep message is an *assistant* role message containing the prose opener,
+    with the structured sections preserved on ``msg_metadata``. If a legacy
+    system-role prep exists from an earlier version, it gets upgraded in place
+    on the next call.
+
+    With ``force=True`` the prose is regenerated even when a prep already exists.
+    Used by the manual /api/journal/trigger-prep endpoint.
     """
     async with async_session() as session:
         result = await session.execute(
@@ -168,33 +334,50 @@ async def ensure_daily_prep_message(
             session.add(conv)
             await session.flush()
 
-        prep_stmt = select(Message).where(
-            Message.conversation_id == conv.id,
-            Message.role == "system",
-        )
+        # Find any existing prep (system or assistant role from any version).
+        prep_stmt = select(Message).where(Message.conversation_id == conv.id)
         existing_prep = None
         for msg in (await session.execute(prep_stmt)).scalars():
             if msg.msg_metadata and msg.msg_metadata.get("kind") == "daily_prep":
                 existing_prep = msg
                 break
 
-        if existing_prep and not force:
+        # If we already have an assistant-role prep with prose content and the
+        # caller didn't ask to force regeneration, we're done.
+        if (
+            existing_prep
+            and not force
+            and existing_prep.role == "assistant"
+            and (existing_prep.content or "").strip()
+        ):
             return existing_prep
 
-        sections = await generate_daily_prep(
+        sections = await gather_daily_sections(
             user_id=user_id, day_date=day_date, user_timezone=user_timezone
         )
+        prose = await _generate_prep_prose(
+            sections=sections, day_date=day_date, user_id=user_id
+        )
+        new_metadata = {"kind": "daily_prep", "sections": sections}
+
         if existing_prep:
-            existing_prep.msg_metadata = {"kind": "daily_prep", "sections": sections}
+            # Upgrade in place: bump role, replace content + metadata.
+            existing_prep.role = "assistant"
+            existing_prep.content = prose
+            existing_prep.msg_metadata = new_metadata
             await session.commit()
             return existing_prep
 
         prep_msg = Message(
             conversation_id=conv.id,
-            role="system",
-            content="",
-            msg_metadata={"kind": "daily_prep", "sections": sections},
+            role="assistant",
+            content=prose,
+            msg_metadata=new_metadata,
         )
         session.add(prep_msg)
         await session.commit()
         return prep_msg
+
+
+# Backwards-compat alias — older imports may use the old name.
+generate_daily_prep = gather_daily_sections