Add streaming status UX and model load state indicator

Streaming status transparency:
- generation_task.py emits 'status' SSE events at each pipeline stage:
  "Analyzing your request..." before intent classification, tool label
  before each tool execution, "Generating/Composing response..." before
  each LLM streaming round
- chat.ts adds streamingStatus ref; cleared on first chunk or done/error;
  includes fast 5s poll loop after warmModel() until model shows as loaded
- ChatView.vue shows pulsing dot + italic status label above content area;
  falls back to blinking cursor once content arrives
- HomeView.vue shows status label in dashboard panel instead of '...'

Model load state indicator:
- /api/chat/status now queries /api/tags and /api/ps in parallel to
  distinguish installed-but-cold vs loaded-in-VRAM model states
- New model status values: 'not_found' | 'cold' | 'loaded' (was 'ready')
- chatReady true for both 'cold' and 'loaded' (cold models still work)
- AppHeader shows 5 states: gray pulse (checking), red (Ollama down),
  orange (not installed), yellow pulse (cold), green (loaded)
- Inline short label ("Cold", "Ready", "Offline", etc.) visible without
  hovering; detailed tooltip on hover

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/fabledassistant/routes/chat.py

@@ -285,7 +285,7 @@ async def warm_model_route():
 @chat_bp.route("/status", methods=["GET"])
 @login_required
 async def chat_status_route():
-    """Check Ollama availability and model readiness."""
+    """Check Ollama availability, model installation, and model load state."""
     uid = get_current_user_id()
     default_model = await get_setting(uid, "default_model", Config.OLLAMA_MODEL)
     result = {
@@ -295,14 +295,26 @@ async def chat_status_route():
     }
     try:
         async with httpx.AsyncClient(timeout=5.0) as client:
-            resp = await client.get(f"{Config.OLLAMA_URL}/api/tags")
-            resp.raise_for_status()
-            result["ollama"] = "available"
-            data = resp.json()
-            model_names = {m["name"] for m in data.get("models", [])}
-            # Match with or without :latest tag
-            if default_model in model_names or f"{default_model}:latest" in model_names:
-                result["model"] = "ready"
+            # Query installed models and loaded models in parallel
+            tags_task = asyncio.create_task(client.get(f"{Config.OLLAMA_URL}/api/tags"))
+            ps_task = asyncio.create_task(client.get(f"{Config.OLLAMA_URL}/api/ps"))
+            tags_resp, ps_resp = await asyncio.gather(tags_task, ps_task, return_exceptions=True)
+
+            if isinstance(tags_resp, Exception):
+                logger.debug("Ollama /api/tags failed: %s", tags_resp)
+            else:
+                tags_resp.raise_for_status()
+                result["ollama"] = "available"
+                model_names = {m["name"] for m in tags_resp.json().get("models", [])}
+                base = default_model.removesuffix(":latest")
+                if default_model in model_names or f"{base}:latest" in model_names:
+                    # Installed — now check if currently loaded in memory
+                    result["model"] = "cold"
+                    if not isinstance(ps_resp, Exception):
+                        ps_resp.raise_for_status()
+                        loaded_names = {m["name"] for m in ps_resp.json().get("models", [])}
+                        if default_model in loaded_names or f"{base}:latest" in loaded_names:
+                            result["model"] = "loaded"
     except Exception:
         logger.debug("Ollama status check failed", exc_info=True)
     return jsonify(result)

src/fabledassistant/services/generation_task.py

@@ -29,6 +29,26 @@ _TOOL_CALL_MARKER = re.compile(r"^\s*\[TOOL_CALLS\]\s*", re.IGNORECASE)
 
 DB_FLUSH_INTERVAL = 5.0  # seconds between partial DB flushes
 
+# Human-readable labels for each tool, shown in the status indicator
+_TOOL_LABELS: dict[str, str] = {
+    "create_task": "Creating task",
+    "create_note": "Creating note",
+    "update_note": "Updating note",
+    "list_tasks": "Searching tasks",
+    "search_notes": "Searching notes",
+    "create_event": "Creating calendar event",
+    "list_events": "Searching calendar",
+    "search_events": "Searching calendar",
+    "update_event": "Updating calendar event",
+    "delete_event": "Removing calendar event",
+    "list_calendars": "Listing calendars",
+    "create_todo": "Creating todo",
+    "list_todos": "Listing todos",
+    "update_todo": "Updating todo",
+    "complete_todo": "Completing todo",
+    "delete_todo": "Removing todo",
+}
+
 
 async def _generate_title(messages: list[dict], model: str) -> str:
     """Ask the LLM for a concise conversation title."""
@@ -121,6 +141,7 @@ async def run_generation(
                     m for m in messages[1:-1]
                     if m.get("role") in ("user", "assistant") and m.get("content")
                 ][-6:]
+                buf.append_event("status", {"status": "Analyzing your request..."})
                 intent = await classify_intent(user_content, tools, intent_model, history=intent_history)
                 if intent.should_execute:
                     logger.info(
@@ -133,6 +154,7 @@ async def run_generation(
                         intent.confidence, intent.tool_name,
                     )
                 if intent.should_execute:
+                    buf.append_event("status", {"status": f"{_TOOL_LABELS.get(intent.tool_name, 'Working')}..."})
                     result = await execute_tool(user_id, intent.tool_name, intent.arguments)
                     logger.info("Intent-routed tool %s result: success=%s", intent.tool_name, result.get("success"))
 
@@ -159,6 +181,7 @@ async def run_generation(
                     })
                     continue  # Next round: LLM streams response incorporating result
 
+            buf.append_event("status", {"status": "Generating response..." if _round == 0 else "Composing response..."})
             async for chunk in stream_chat_with_tools(messages, model, tools=tools):
                 if buf.cancel_event.is_set():
                     cancelled = True
@@ -188,6 +211,7 @@ async def run_generation(
                         tool_name = fn.get("name", "")
                         arguments = fn.get("arguments", {})
                         logger.info("Executing tool: %s(%s)", tool_name, json.dumps(arguments)[:200])
+                        buf.append_event("status", {"status": f"{_TOOL_LABELS.get(tool_name, 'Working')}..."})
 
                         result = await execute_tool(user_id, tool_name, arguments)
                         logger.info("Tool %s result: success=%s", tool_name, result.get("success"))