Merge pull request 'feat: unified lookup tool, Wikipedia integration, weather & briefing UX' (#41) from dev into main

trafilatura.extract dispatched via run_in_executor isn't safe to run
concurrently — two parallel calls can crash the process with a
libxml2-level double free. The top-level Wikipedia+SearXNG gather is
fine; only the inner per-article extraction needs to stay sequential,
matching the pre-parallelization behavior.

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

.forgejo/workflows/ci.yml

@@ -1,13 +1,27 @@
 # CI runs first; build only proceeds if all checks pass.
 #
-# Push to dev:       typecheck + lint + test → build :dev + :<sha>
-# Tag v* (release):  typecheck + lint + test → build :latest + :<sha> + :<version>
-# Pull request:      no CI run — code is validated on dev push before any PR is opened
+# Push to dev:       typecheck + lint + test + build :dev + :<sha>
+# Tag v* (release):  typecheck + lint + test + build :latest + :<sha> + :<version>
+#
+# main pushes are NOT gated here: a merge to main only happens after
+# dev has already passed CI, and the release tag is the sole trigger
+# for a production image. Re-running CI on the merge commit just burns
+# runner time without changing the outcome.
 #
 # To cut a release:
 #   Create a release via the Forgejo UI on main with a v* tag name.
 #   The tag push triggers this workflow; build job pushes :latest + :<version>.
 #
+# PRs aren't triggered on purpose — this is a solo dev→main flow, so
+# gating on branch push is already enough.
+#
+# NOTE on the `if:` guards below: Forgejo Actions does not consistently
+# honor `on.push.branches` as a filter — merge commits landing on main
+# still trigger the workflow, producing redundant runs on the same SHA
+# that was already gated on dev. Every job therefore repeats the ref
+# check so main pushes trigger the workflow but every job skips
+# immediately (no runner time, no duplicate work).
+#
 # Required secrets (repo → Settings → Secrets → Actions):
 #   REGISTRY_USER   — your Forgejo username
 #   REGISTRY_TOKEN  — Forgejo PAT with write:packages scope
@@ -28,8 +42,18 @@ on:
       - "assets/**"
       - "fable-mcp/**"
       - ".forgejo/workflows/ci.yml"
-  # pull_request trigger intentionally omitted — all changes go through dev
-  # first, where CI already runs on push. PR runs would be redundant duplication.
+
+# Cancel older runs on the same branch when a newer push lands. Tag runs
+# get their own group implicitly (refs/tags/v1.2.3 ≠ refs/heads/dev) and
+# are never cancelled, so a release build can't kill itself mid-flight.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: ${{ !startsWith(github.ref, 'refs/tags/') }}
+
+# Least-privilege default. Jobs that need more (build pushes to the
+# registry) upgrade explicitly.
+permissions:
+  contents: read
 
 env:
   REGISTRY: git.fabledsword.com
@@ -38,15 +62,18 @@ env:
 jobs:
   typecheck:
     name: TypeScript typecheck
-    runs-on: py3.12-node22
+    # Skip on main merge-commit pushes — see workflow header comment.
+    if: github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/v')
+    runs-on: ci-runner
     steps:
       - uses: actions/checkout@v6
 
-      - uses: actions/setup-node@v6
+      - name: Cache npm download cache
+        uses: actions/cache@v4
         with:
-          node-version: "22"
-          cache: "npm"
-          cache-dependency-path: frontend/package-lock.json
+          path: ~/.npm
+          key: npm-cache-${{ hashFiles('frontend/package-lock.json') }}
+          restore-keys: npm-cache-
 
       - name: Install dependencies
         run: npm ci
@@ -58,52 +85,57 @@ jobs:
 
   lint:
     name: Python lint
-    runs-on: py3.12-node22
+    if: github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/v')
+    runs-on: ci-runner
     steps:
       - uses: actions/checkout@v6
 
-      - name: Install ruff
-        run: pip install --break-system-packages ruff
-
+      # ruff is pre-installed in the ci-runner base image — no install
+      # step needed, lint runs in ~2s.
       - name: Lint
         run: ruff check src/
 
   test:
     name: Python tests
-    runs-on: py3.12-node22
+    if: github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/v')
+    runs-on: ci-runner
     steps:
       - uses: actions/checkout@v6
 
-      # Python 3.12 is pre-installed in the runner-base image (py3.12-node22).
-      - name: Cache pip wheels
-        uses: actions/cache@v3
+      - name: Cache uv packages
+        uses: actions/cache@v4
         with:
-          path: ~/.cache/pip
-          key: pip-${{ hashFiles('pyproject.toml') }}
-          restore-keys: pip-
+          path: ~/.cache/uv
+          key: uv-${{ hashFiles('pyproject.toml') }}
+          restore-keys: uv-
 
       - name: Create virtual environment
-        run: python3.12 -m venv /opt/venv
+        run: uv venv /opt/venv
 
       - name: Install package with dev deps
         run: |
-          /opt/venv/bin/pip install --upgrade pip setuptools wheel
-          /opt/venv/bin/pip install --no-build-isolation http-ece
-          /opt/venv/bin/pip install -e ".[dev]"
+          # http-ece doesn't declare setuptools as a build dep, and uv
+          # creates bare venvs without it. Install setuptools first so
+          # --no-build-isolation can find it.
+          uv pip install --python /opt/venv/bin/python setuptools wheel
+          uv pip install --python /opt/venv/bin/python --no-build-isolation http-ece
+          uv pip install --python /opt/venv/bin/python -e ".[dev]"
 
       - name: Run tests
-        run: /opt/venv/bin/python -m pytest tests/ -v
+        run: /opt/venv/bin/python -m pytest tests/ -q
 
   build:
     name: Build & push image
     needs: [typecheck, lint, test]
     # Build on dev branch pushes and version tag pushes only.
-    # main branch pushes run CI for safety but do not build —
-    # the release tag (v*) is the sole trigger for a production image.
-    if: |
-      github.event_name == 'push' &&
-      (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/'))
-    runs-on: py3.12-node22
+    # Mirrors the ref guard on the gate jobs above — main merge-commit
+    # pushes skip here too, so no production image is ever built from a
+    # raw main push (only from the v* tag the release creates).
+    if: github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/v')
+    runs-on: ci-runner
+    permissions:
+      contents: read
+      packages: write
     steps:
       - uses: actions/checkout@v6
 
@@ -122,11 +154,14 @@ jobs:
           echo "build_version=$BUILD_VERSION" >> $GITHUB_OUTPUT
 
       - name: Free disk space
+        # Self-hosted runner housekeeping. Two-step cleanup:
+        # 1. Prune dangling containers/images globally (stops the runner
+        #    from accumulating cruft from past failed builds).
+        # 2. Trim the BuildKit layer cache to a 5GB ceiling so the pip
+        #    mount cache survives but old intermediate layers don't
+        #    accumulate indefinitely.
         run: |
-          # Remove all unused images (including old :SHA tags) and containers.
           docker system prune -af || true
-          # Keep the local BuildKit cache bounded so pip mount cache survives
-          # but stale intermediate layers don't accumulate indefinitely.
           docker builder prune --keep-storage 5g -f || true
 
       - name: Set up Docker Buildx
@@ -147,3 +182,10 @@ jobs:
           provenance: false
           tags: ${{ steps.tags.outputs.value }}
           build-args: BUILD_VERSION=${{ steps.tags.outputs.build_version }}
+          # Registry-backed layer cache. Pull from :cache to prime
+          # BuildKit, push updated layers back to :cache so the next
+          # build starts warm even if the runner's local cache was
+          # pruned. `mode=max` exports all intermediate layers, not
+          # just the final image, which is what gives the ~80% speedup.
+          cache-from: type=registry,ref=${{ env.IMAGE }}:cache
+          cache-to: type=registry,ref=${{ env.IMAGE }}:cache,mode=max,ignore-error=true

alembic/versions/0038_add_rss_item_full_content.py

@@ -0,0 +1,34 @@
+"""Add content_full and context_prepared caches to rss_items.
+
+Revision ID: 0038
+Revises: 0037
+Create Date: 2026-04-13
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0038"
+down_revision = "0037"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("rss_items", sa.Column("content_full", sa.Text(), nullable=True))
+    op.add_column(
+        "rss_items",
+        sa.Column("context_prepared", sa.Text(), nullable=True),
+    )
+    op.add_column(
+        "rss_items",
+        sa.Column("content_fetched_at", sa.DateTime(timezone=True), nullable=True),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("rss_items", "content_fetched_at")
+    op.drop_column("rss_items", "context_prepared")
+    op.drop_column("rss_items", "content_full")

alembic/versions/0039_add_rss_item_discussion_note.py

@@ -0,0 +1,38 @@
+"""Link rss_items to their discussion-summary note.
+
+Revision ID: 0039
+Revises: 0038
+Create Date: 2026-04-14
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0039"
+down_revision = "0038"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "rss_items",
+        sa.Column("discussion_note_id", sa.BigInteger(), nullable=True),
+    )
+    op.create_foreign_key(
+        "fk_rss_items_discussion_note_id",
+        "rss_items",
+        "notes",
+        ["discussion_note_id"],
+        ["id"],
+        ondelete="SET NULL",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint(
+        "fk_rss_items_discussion_note_id", "rss_items", type_="foreignkey"
+    )
+    op.drop_column("rss_items", "discussion_note_id")

docs/2026-04-10-agentic-briefing-design.md

@@ -0,0 +1,216 @@
+# Agentic Briefing — Design Spec
+
+**Date:** 2026-04-10
+**Status:** Proposed
+**Author:** bvandeusen + Claude
+
+---
+
+## Problem
+
+The current briefing pipeline hallucinates calendar events, tasks, and news items that do not exist in the user's actual data. Observed examples from production:
+
+- A morning briefing asserting "your dentist appointment is still in progress" when no such event existed
+- An 8am check-in mentioning "a quick meeting at 10:30 AM" with no backing calendar entry
+- A midday check-in inventing "a team huddle at 2:30 PM" and "the Q2 budget draft due by Friday"
+- The model calling `search_images` in response to a clarifying question about a fabricated meeting
+
+These are not bugs in data retrieval — the data gathering code (`_gather_internal`, `_gather_external`) returns correct values. They are a structural consequence of how the briefing context is assembled.
+
+## Root cause — the "no receipt" problem
+
+The current `run_compilation` pipeline does this:
+
+1. Python code gathers data (tasks, events, weather, news) from the database
+2. Python formats the data into a structured text blob as the user-role message: `TODAY'S EVENTS: ...`, `DUE TODAY: ...`, etc.
+3. The LLM is called **once** with `[system_prompt, user_prompt]` and produces prose
+4. Only the prose reply is written to the conversation. **The underlying data is never persisted in the conversation history.**
+
+When the user later chats in the briefing conversation, the chat endpoint loads the full conversation history — which contains the model's *prose* from earlier but not the data that prose was derived from. The model's own prior output becomes the only source of "truth" available for follow-up questions. If that prose asserted a fact (real or hallucinated), the model has no way to distinguish it from ground truth when generating the next reply, and it will double down.
+
+Compounding factors:
+
+- **Empty sections are silently omitted.** If `calendar_events` is empty, the user prompt contains no `TODAY'S EVENTS:` line at all. The model has no explicit "zero events" signal — combined with an imperative system prompt ("note calendar events and tasks"), it interprets the silence as "I should mention some" and fabricates.
+- **Scheduled slot injections append synthetic turns.** `run_slot_injection` writes a fake `[Midday briefing update]` user message and the assistant reply into the persistent conversation. By evening, the chat history contains three separate briefings, each potentially with errors, all treated as equal-weight context on follow-up.
+- **The `search_images` tool is available during briefing chat**, with a negative-instruction description ("Not for factual questions"). Small and mid-sized models frequently ignore negative guidance in tool descriptions and call the tool anyway.
+
+## Solution — agentic briefing (the receipt model)
+
+Replace the one-shot synthesis with a tool-call loop. The briefing is no longer "a text blob synthesized from pre-gathered data." It is **a scheduled agent run**: the LLM is given a system prompt, a curated set of read-only data tools, and a trigger ("generate the morning briefing"). The model must call tools to see what exists. Every tool call and tool result becomes part of the conversation history, where it lives as a permanent, structured receipt.
+
+### Why this fixes the hallucination
+
+When the model calls `list_events(today) → []`, that empty array is now a persistent message in the conversation. On a follow-up question like "what meeting?", the chat endpoint loads the conversation and the model sees its own tool result from the morning showing no events. Answering "you had a meeting at 10:30" would require the model to directly contradict a tool result sitting two messages back — something LLMs are much more reliable at avoiding than contradicting their own prior prose.
+
+In short: **the model cannot fabricate what has a visible receipt proving it does not exist.**
+
+### What the model sees — before vs after
+
+**Before** — the model sees one structured blob and produces prose. The blob is discarded.
+
+```
+[system] You are a personal assistant... weave together what matters...
+[user]   Date: 2026-04-10
+         WEATHER: Home — partly cloudy, 8–16°C
+         DUE TODAY: Fix briefing hallucinations
+         OVERDUE (2 tasks): ...
+[assistant] Morning! Looks like a quiet day with two overdue items...
+```
+
+**After** — the model is given tools and iterates to ground truth.
+
+```
+[system] You are the user's personal assistant giving their morning briefing.
+         Use tools to see what's relevant. Only mention things you learned from
+         tool calls. If a tool returns nothing, say so honestly.
+[user]   Generate the morning briefing.
+[assistant] tool_call: list_tasks(filter="due_today")
+[tool]   [{"id": 81, "title": "Fix briefing hallucinations", ...}]
+[assistant] tool_call: list_tasks(filter="overdue")
+[tool]   [{"id": 42, ...}, {"id": 43, ...}]
+[assistant] tool_call: list_events(today)
+[tool]   []
+[assistant] tool_call: get_weather(location="home")
+[tool]   {"description": "partly cloudy", "temp_min": 8, "temp_max": 16}
+[assistant] tool_call: get_rss_items(max=8)
+[tool]   [...]
+[assistant] Morning! Partly cloudy today, 8 to 16 — nothing on the calendar
+         so it's a clean run at the desk. Two things to keep in mind...
+```
+
+The conversation now contains verifiable receipts: `list_events(today)` returned `[]`, and that result sits in context forever (until pruned). Follow-up questions operate against those receipts.
+
+## Architecture
+
+### Existing infrastructure (reused, not rebuilt)
+
+The codebase already has the agentic primitives — they're used for regular chat:
+
+- **`llm.py::stream_chat_with_tools`** — the streaming tool-use loop that talks to Ollama with a `tools` parameter and yields tool-call chunks
+- **`generation_task.py::_stream_with_retry`** — wraps `stream_chat_with_tools` with retry-on-500 behavior for cold-model races
+- **`tools.py`** — defines 40+ tool schemas and an execution dispatcher
+
+The briefing bypasses all of this and calls a one-shot `_llm_synthesise` helper. The refactor is mainly "route briefings through the same pipeline regular chat already uses."
+
+### New modules
+
+**`briefing_tools.py`** — a small wrapper exposing a curated read-only subset of `tools.py` for briefing runs. This is an **explicit allowlist**, not a blocklist, so newly-added tools must be opted in:
+
+| Tool | Purpose |
+|---|---|
+| `list_tasks` (with filter args) | See what's actionable today, overdue, high priority |
+| `list_events` (today / upcoming) | Know what's on the calendar |
+| `get_weather` | Current/forecast weather |
+| `get_rss_items` | Pull news themes filtered by user preferences |
+| `list_projects` | Understand project context |
+| `search_projects` | Surface active project summaries |
+| `list_notes` (recent) | Capture follow-ups from yesterday |
+
+**Explicitly omitted** from the briefing tool set:
+
+- `search_images`, `search_web`, `research_topic`, `read_article` — external search is not a briefing concern, and `search_images` is the source of the "Peter Kyle Science Secretary" image-search bug
+- All `create_*`, `update_*`, `delete_*` — briefings are read-only; a scheduled background job must not decide to mutate the user's data on its own
+- `set_rag_scope`, `calculate` — not relevant to briefing content
+
+### New briefing function
+
+**`briefing_pipeline.py::run_agentic_briefing(user_id, slot, model, conversation_id)`** replaces `run_compilation`'s body (and eventually `run_slot_injection`). Internally:
+
+1. Build a slot-specific system prompt (see below)
+2. Load the curated briefing tools from `briefing_tools.py`
+3. Seed messages with `[system, user]` where the user message is a simple trigger like `"Generate the morning briefing."`
+4. Enter a tool-call loop (max 8 iterations):
+   - Call `stream_chat_with_tools`
+   - If the model returns `tool_calls`, execute them via the existing dispatcher, append tool results, continue
+   - If the model returns a final assistant message with no pending tool calls, break
+5. Return `(final_prose, full_message_list, metadata)`
+
+The full message list is important: it's written to the conversation along with the final prose, so the tool-call receipts become part of the persistent record.
+
+### Slot-specific system prompts
+
+Compilation (full morning briefing):
+
+```
+You are the user's personal assistant giving their full morning briefing.
+Use the tools available to see what's actually relevant today — tasks due,
+overdue items, events on the calendar, weather, news themes, project state
+— and weave it into a warm, natural-sounding summary.
+
+Rules:
+- Call tools to see the data. Never assert facts you didn't learn from a tool.
+- If a tool returns nothing (no events today, no overdue tasks), say so
+  honestly. Don't fabricate items to fill space.
+- Write flowing prose. No markdown, no headers, no bullet points.
+- Aim for 6–10 sentences. Skip topics that have nothing interesting.
+- Close on one or two concrete, actionable suggestions.
+
+User profile (for tone and preferences):
+{profile_body}
+```
+
+Check-ins (midday, afternoon):
+
+```
+You are the user's personal assistant giving a brief {slot} check-in.
+Use tools to see what's changed since this morning. Focus on progress
+and what's still unaddressed.
+
+Rules:
+- Call tools to see current state. Never assert facts without tool results.
+- If nothing meaningful has changed, say so briefly — don't invent progress.
+- 3–5 sentences, natural prose, no markdown.
+```
+
+### Conversation hygiene — removing the fake user messages
+
+The current scheduler appends two fake messages on every slot injection:
+
+```python
+await post_message(conv.id, "user", f"[{slot.title()} briefing update]")
+await post_message(conv.id, "assistant", text)
+```
+
+Under the agentic model, we drop the fake `"user"` message entirely. Slot updates become plain assistant messages tagged with `metadata.briefing_slot = "midday"`. The chat endpoint's message loader is updated to filter these when building the LLM context on follow-ups, so a user chatting in the briefing conversation doesn't see three earlier briefings smashed into their history. The UI continues to show them as visible timeline entries.
+
+(This is the Option A filter from the earlier discussion — a small, surgical change compared to migrating briefings to a separate sidecar table. Sidecar storage remains a possible future step.)
+
+### Ollama setup compatibility
+
+The existing Ollama deployment uses non-parallel mode across two GPUs, with a concern about context duplication between cards. This is the correct setup for agentic briefings:
+
+- Each tool-call iteration shares the same KV cache on the same GPU, so appending tool results is cheap
+- There is no race where a second iteration could land on a different card with a different cache state
+- The trade-off is serialization: a briefing in progress will block a concurrent user chat request until it finishes, but scheduled briefings are rare enough (4× per day) that this is acceptable
+
+If GPU contention becomes a problem later, the right lever is pinning specific models to specific GPUs (e.g., background tasks on GPU 1, interactive models on GPU 0) — not enabling parallelism.
+
+## Cost & trade-offs
+
+- **Latency:** a briefing now makes 5–7 inference calls (one per tool-call decision plus the final prose) instead of 1. On a local Ollama with a 7B model, expect 15–40s per briefing vs the current 5–10s. Acceptable for a background job; if it becomes painful at the user-facing check-in slots, investigate letting the model batch independent tool calls in a single turn (Ollama supports this).
+- **Model requirements:** the default model must be reliable at tool calling. `qwen2.5:7b`, `llama3.1:8b`, `mistral-small-3:24b`, and similar handle it well. Models in the ≤3B class typically fail — they either emit no tool calls and return empty prose, or hallucinate invalid tool arguments. If a user's `default_model` is too small, agentic mode should fall back to legacy mode with a log warning.
+- **Context growth:** tool results bloat the conversation. At 8 tool calls per compilation × 4 slots per day, a daily briefing conversation can reach 20-30 KB of JSON-heavy history. Fine for a day; aged briefings should be archived/rolled up after 7 days.
+- **Tool subset drift:** someone adds a new mutating tool to `tools.py` and forgets to update the briefing allowlist. Mitigated by the allowlist model — the default for new tools is "not exposed to briefings."
+- **Infinite loop safety:** a buggy model could tool-call forever. Hard cap at 8 iterations, log a warning if hit, return whatever prose was last produced (or a fallback message).
+
+## Migration path
+
+Ship incrementally, each step independently reversible:
+
+**PR 1 — Agentic compilation behind a feature flag.** Add `briefing_tools.py`, add `run_agentic_briefing`, add a per-user setting `briefing_mode: "legacy" | "agentic"` (default legacy). Route only the 4am compilation through the new path when the flag is set. Keep slot-injection on the legacy path. Enable the flag on the author's account first, validate output quality over several days, then flip the default for all users. No DB migration required — the setting lives in the existing `settings` table.
+
+**PR 2 — Agentic slot injections + conversation hygiene.** Migrate midday/afternoon check-ins to the same pipeline. Remove the fake `[Midday briefing update]` user-role message; slot updates become plain assistant messages tagged with `metadata.briefing_slot`. Add a chat-message-loader filter that excludes slot-tagged messages from the LLM context on follow-ups (they remain visible in the UI).
+
+**PR 3 — UI polish.** Collapsed tool-call status row in the briefing card ("✓ checked calendar · ✓ looked at tasks · ✓ pulled weather"), expanding to show tool results on click. Tool-result cards (weather, news, task list) rendered inline where useful.
+
+**PR 4 (optional) — Sidecar storage for briefing snapshots.** If the chat-filter approach in PR 2 feels too hacky, migrate briefings out of the conversations table and into a dedicated `briefing_snapshots` table. Frontend renders them as pinned timeline cards separate from chat. Larger refactor; defer until PR 1–3 prove the approach works.
+
+## Secondary win — tightening the main chat system prompt
+
+The regular chat is already agentic (it uses `stream_chat_with_tools`), but its system prompt does not explicitly require the model to ground factual claims in tool results. The prompt discipline introduced for briefings — *"Never assert facts you didn't learn from a tool. If a tool returns nothing, say so honestly."* — is worth applying to the main chat system prompt in a follow-up PR. The mechanism already works; only the framing needs tightening.
+
+## Out of scope
+
+- The Android Flutter client's failure to render `search_images` tool-result cards. This is a separate rendering gap in the mobile app and does not affect the server-side fix. Tracked separately.
+- Re-evaluating the Ollama parallelism setting. The current non-parallel config is correct for this work.
+- Replacing the background model for title/summary/observation extraction. That model's role is unrelated to briefings.

docs/architecture.md

@@ -212,8 +212,8 @@ Permission resolution is centralised in `services/access.py`. `get_project_permi
 | `services/api_keys.py` | `generate_key()`, `create_api_key()`, `list_api_keys()`, `revoke_api_key()`, `lookup_key()` (SHA-256 hash lookup) |
 | `services/llm.py` | `build_context()`, RAG injection, history summarisation, `stream_chat_with_tools()`, URL fetching, SSRF guard |
 | `services/generation_task.py` | `run_generation()` — full chat pipeline: intent routing, tool loop, SSE fan-out, push notification; `run_assist_generation()` |
-| `services/intent.py` | `classify_intent()` — fast non-streaming LLM call; intent skip heuristic; `_PRIOR_WORK_REFS` fast-path |
-| `services/tools.py` | All LLM tool definitions + `execute_tool(user_id, tool_name, arguments, conv_id=None, workspace_project_id=None)` dispatcher; duplicate guards; `_resolve_project()` 4-step lookup; `search_projects` and `set_rag_scope` tools |
+| ~~`services/intent.py`~~ | Removed — intent routing eliminated; the main model handles all tool routing directly |
+| `services/tools/` | LLM tool package — decorator-based registry (`_registry.py`), shared helpers (`_helpers.py`), and one module per domain: `notes.py` (create/update/delete/search/list/read), `tasks.py` (list/log_work), `entities.py` (save_person/save_place/lists), `projects.py`, `calendar.py`, `web.py`, `rag.py`, `profile.py`, `rss.py`, `weather.py`, `utility.py` (calculate). `execute_tool()` and `get_tools_for_user()` are the public API. |
 | `services/projects.py` | Project CRUD + `generate_project_summary()` (Ollama, fire-and-forget) + `backfill_project_summaries()` (startup) |
 | `services/embeddings.py` | `upsert_note_embedding()`, `semantic_search_notes(orphan_only=False)` (pgvector cosine similarity) |
 | `services/generation_buffer.py` | In-memory SSE event buffer; `cancel_event`; 60s cleanup; supports both chat (int keys) and assist (string keys) |
@@ -231,7 +231,7 @@ Permission resolution is centralised in `services/access.py`. `get_project_permi
 | `services/briefing_scheduler.py` | APScheduler `BackgroundScheduler`; slots with catch-up logic; async-safe via `asyncio.create_task` |
 | `services/briefing_conversations.py` | Briefing conversation persistence and history queries |
 | `services/briefing_profile.py` | Per-user profile note that the assistant updates over time |
-| `services/research.py` | SearXNG research pipeline: 5 sub-queries → parallel fetch → synthesis; `search_images` for image category |
+| `services/research.py` | SearXNG research pipeline: sub-queries → parallel fetch → outline → section synthesis → executive summary → index note with linked section notes |
 | `services/events.py` | Internal events CRUD: `list_events`, `create_event`, `update_event`, `delete_event`, `get_event`; source of truth for all event LLM tools |
 | `routes/events.py` | `/api/events` — event CRUD routes |
 | `services/caldav.py` | Optional CalDAV sync — user-configured external server; syncs to/from internal store via `caldav_uid` FK; `is_caldav_configured()` guards tool activation |
@@ -291,7 +291,7 @@ Permission resolution is centralised in `services/access.py`. `get_project_permi
 | `services/access.py` | Permission resolution for all shared resources |
 | `services/llm.py` | `build_context()`, RAG injection, history summarisation |
 | `services/generation_task.py` | SSE streaming, tool-call loop, GenerationBuffer management |
-| `services/tools.py` | All LLM tool implementations (`create_note`, `search_notes`, `get_weather`, …) |
+| `services/tools/` | LLM tool implementations (38 tools across 11 modules); decorator-based registry |
 | `services/embeddings.py` | `upsert_note_embedding()`, `semantic_search_notes()` |
 | `services/briefing_pipeline.py` | Two-lane parallel gather → LLM synthesis → briefing output |
 | `services/briefing_scheduler.py` | APScheduler integration, catch-up logic for missed slots |
@@ -311,26 +311,22 @@ See [sso-oauth.md](sso-oauth.md) for provider-specific setup instructions.
 
 ## LLM Pipeline Internals
 
-### Intent Routing
+### Tool Routing
 
-Before the main model runs, a lightweight intent classifier (`services/intent.py`) runs concurrently with `build_context()`. It makes a fast non-streaming call using a smaller dedicated model (`OLLAMA_INTENT_MODEL`, default `qwen2.5:7b`) to determine if the message requires a tool call.
-
-**Skip heuristic** — Intent classification is skipped entirely for short messages (≤10 words) with no action/object keywords, saving 400–800ms on conversational replies.
-
-**Prior-work fast-path** — `_PRIOR_WORK_REFS` regex detects phrases like "research you did", "note you made", "using your research" and returns no-tool immediately, preventing `search_web` from firing when the user references existing notes.
-
-If a tool is detected, the intent's one-sentence `ack` field is streamed as the first chunk (TTFT), the tool executes, then the main model generates a follow-up with the tool result. For chat-only responses the main model streams directly.
+No separate intent router — the main model handles all tool routing directly via Ollama's structured tool-calling output. The model receives the full tool schema list and decides whether to call a tool or respond conversationally. Extended reasoning (`think=True`) is always on for qwen3-class models: content-based gating was tried but exposed tool-call template fragility on short tool-intent prompts.
 
 ### Tool Loop
 
-Multi-round tool loop (max 5 rounds). All implementations in `services/tools.py`; `execute_tool(user_id, tool_name, arguments, conv_id=None, workspace_project_id=None)` is the dispatcher. `conv_id` and `workspace_project_id` are threaded in from `run_generation()` so tools like `set_rag_scope` can write to the current conversation.
+Multi-round tool loop (max 5 rounds). All implementations in `services/tools/` (decorator-based registry); `execute_tool(user_id, tool_name, arguments, conv_id=None, workspace_project_id=None)` is the dispatcher. `conv_id` and `workspace_project_id` are threaded in from `run_generation()` so tools like `set_rag_scope` can write to the current conversation.
 
-**Duplicate protection on `create_note` / `create_task`:**
+**Unified `create_note` tool** — creates both notes and tasks. Setting `status` (e.g. `"todo"`) creates a task; omitting it creates a knowledge note. All task fields (due_date, priority, milestone, parent_task, recurrence_rule) are available on the single tool.
+
+**Duplicate protection on `create_note`:**
 1. Exact title match (case-insensitive) → hard block, redirect to `update_note`
 2. Fuzzy title match (SequenceMatcher ≥ 82%; punctuation stripped before candidate search) → hard block
-3. Semantic content similarity (threshold 0.90, body ≥ 200 chars) → soft block with `requires_confirmation: true`
+3. Semantic content similarity (threshold 0.90, body ≥ 80 chars) → soft block with `requires_confirmation: true`
 
-**Project resolution** (`_resolve_project`): 4-step lookup — (1) exact DB match, (2) `query in title` substring, (3) `title in query` reverse substring, (4) SequenceMatcher ≥ 0.55.
+**Project resolution** (`_helpers.resolve_project`): 4-step lookup — (1) exact DB match, (2) `query in title` substring, (3) `title in query` reverse substring, (4) SequenceMatcher ≥ 0.55.
 
 ### Context Window and Summarisation
 
@@ -344,8 +340,11 @@ History summarisation threshold: 30 messages. Keeps 8 recent messages. Summary m
 1. Intent model generates 5 focused sub-queries
 2. All 5 SearXNG queries run in parallel (200ms stagger to avoid rate limiter)
 3. Up to 15 unique URLs fetched in parallel
-4. Up to 12 sources passed to synthesis LLM
-5. Result saved as a note with `tags=["research"]`
+4. LLM generates an outline (2–8 sections with title + focus)
+5. Each section synthesised in parallel from relevant sources
+6. Executive summary generated from all section content
+7. Index note created with executive summary + links to section notes; section notes linked back via `parent_id`
+8. Falls back to single-note synthesis if outline generation fails
 
 SearXNG tip: add the app server IP to `botdetection.ip_lists.pass_ip` in SearXNG `settings.yml` to bypass the rate limiter for trusted backend requests.
 

docs/features.md

@@ -68,7 +68,7 @@ Full conversation history with SSE streaming. Features:
 
 ## Web Research
 
-The assistant can search the web (SearXNG) and fetch pages, synthesising findings into notes. A lightweight `search_web` tool answers quick questions inline without saving. Requires `SEARXNG_URL` to be configured.
+The assistant can search the web (SearXNG) and fetch pages, synthesising findings into a structured multi-note research output: an index note with an executive summary and links to focused section notes. Each section covers a distinct aspect of the topic with cited sources. Falls back to a single note when outline generation fails. A lightweight `search_web` tool answers quick questions inline without saving. Requires `SEARXNG_URL` to be configured.
 
 ## Calendar
 

docs/superpowers/plans/2026-04-08-note-type-editors.md

@@ -0,0 +1,786 @@
+# Specialized Note Type Editors — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace the generic note editor with type-specialized form-first views for Person, Place, and List, and fix tab navigation so focus flows logically from title through content fields, skipping the formatting toolbar.
+
+**Architecture:** `NoteEditorView.vue` gains type-conditional template sections. When `noteType` is `person` or `place`, the main editor area renders a structured form with the TipTap editor in a secondary "Notes" section. When `noteType` is `list`, a dedicated list builder replaces TipTap as the primary interface. `MarkdownToolbar.vue` gets `tabindex="-1"` on buttons. Backend `_note_to_item` gains new person/place fields.
+
+**Tech Stack:** Vue 3 Composition API, TipTap editor, TypeScript, scoped CSS.
+
+---
+
+## File Map
+
+| Action | Path |
+|--------|------|
+| Modify | `frontend/src/views/NoteEditorView.vue` |
+| Modify | `frontend/src/components/MarkdownToolbar.vue` |
+| Modify | `frontend/src/views/KnowledgeView.vue` |
+| Modify | `src/fabledassistant/services/knowledge.py` |
+
+---
+
+### Task 1: Tab navigation fix — toolbar tabindex + auto-focus
+
+**Files:**
+- Modify: `frontend/src/components/MarkdownToolbar.vue`
+- Modify: `frontend/src/views/NoteEditorView.vue`
+
+**Context:** The MarkdownToolbar renders buttons via `v-for` in a single `<button>` element. Adding `tabindex="-1"` removes them from tab order while keeping them clickable. The NoteEditorView already has a `titleRef` — auto-focus on mount needs to call `.focus()` on it. The title placeholder should vary by note type.
+
+- [ ] **Step 1: Add tabindex="-1" to toolbar buttons**
+
+In `frontend/src/components/MarkdownToolbar.vue`, find:
+
+```html
+        <button
+          v-for="btn in group"
+          :key="btn.id"
+          :class="['md-btn', { active: btn.isActive() }]"
+          :title="btn.title"
+          type="button"
+          @mousedown.prevent="btn.command()"
+        >
+```
+
+Replace with:
+
+```html
+        <button
+          v-for="btn in group"
+          :key="btn.id"
+          :class="['md-btn', { active: btn.isActive() }]"
+          :title="btn.title"
+          type="button"
+          tabindex="-1"
+          @mousedown.prevent="btn.command()"
+        >
+```
+
+- [ ] **Step 2: Add auto-focus on mount and type-dependent placeholder**
+
+In `frontend/src/views/NoteEditorView.vue`, find the title input:
+
+```html
+      <input
+        ref="titleRef"
+        v-model="title"
+        type="text"
+        placeholder="Title"
+        class="title-input"
+```
+
+Replace with:
+
+```html
+      <input
+        ref="titleRef"
+        v-model="title"
+        type="text"
+        :placeholder="titlePlaceholder"
+        class="title-input"
+```
+
+Add the computed property in the `<script setup>` section, after the `isEditing` computed:
+
+```ts
+const titlePlaceholder = computed(() => {
+  switch (noteType.value) {
+    case 'person': return 'Name';
+    case 'place': return 'Place name';
+    case 'list': return 'List title';
+    default: return 'Title';
+  }
+});
+```
+
+- [ ] **Step 3: Auto-focus title on mount**
+
+In the `onMounted` callback, after all the data loading logic (after the draft restore try/catch block), add:
+
+```ts
+  await nextTick();
+  titleRef.value?.focus();
+```
+
+- [ ] **Step 4: Verify TypeScript compiles**
+
+```bash
+cd frontend && npx tsc --noEmit
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add frontend/src/components/MarkdownToolbar.vue frontend/src/views/NoteEditorView.vue
+git commit -m "feat(editor): skip toolbar in tab order; auto-focus title; type-dependent placeholders"
+```
+
+---
+
+### Task 2: Person editor — form-first layout
+
+**Files:**
+- Modify: `frontend/src/views/NoteEditorView.vue`
+
+**Context:** When `noteType === 'person'`, the main content area should render a contact card form instead of the TipTap-first editor. The person metadata fields (currently in the sidebar) move to the main area, and new fields (birthday, organization, address) are added. The TipTap editor becomes a collapsible "Notes" section below. The sidebar keeps project/tags/type/etc but loses the person-specific fields.
+
+- [ ] **Step 1: Add the person form template**
+
+In the template, find the `<!-- ── Main column ──` section. The current structure is:
+
+```html
+      <div class="note-main" @keydown.ctrl.e.prevent="tiptapEditor?.commands.focus()">
+        <div class="body-tabs-row">
+          ...
+        </div>
+        <!-- Streaming/Review/Normal editor templates -->
+      </div>
+```
+
+Wrap the existing main column content in a `v-if="noteType === 'note'"` (and also show it for any type not person/place/list), and add a person form block. Replace the opening of the main column content:
+
+Find the `<div class="note-main"` line and the content inside it up to `</div>` that closes `.note-main`. Wrap all existing content inside:
+
+```html
+      <div class="note-main">
+        <!-- ── Person form ──────────────────────────────────────── -->
+        <template v-if="noteType === 'person'">
+          <div class="entity-form">
+            <div class="ef-field">
+              <label class="ef-label">Relationship</label>
+              <input class="ef-input" v-model="entityMeta.relationship" placeholder="e.g. Friend, Colleague, Family" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Birthday</label>
+              <input class="ef-input" type="date" v-model="entityMeta.birthday" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Email</label>
+              <input class="ef-input" type="email" v-model="entityMeta.email" placeholder="email@example.com" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Phone</label>
+              <input class="ef-input" type="tel" v-model="entityMeta.phone" placeholder="+1 555 000 0000" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Organization</label>
+              <input class="ef-input" v-model="entityMeta.organization" placeholder="Company or organization" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Address</label>
+              <input class="ef-input" v-model="entityMeta.address" placeholder="Street, City, State" @input="markDirty" />
+            </div>
+          </div>
+          <div class="notes-section">
+            <button class="notes-toggle" @click="notesExpanded = !notesExpanded">
+              {{ notesExpanded ? '▾' : '▸' }} Notes
+            </button>
+            <div v-if="notesExpanded" class="notes-editor-wrap">
+              <MarkdownToolbar v-show="!showPreview" :editor="tiptapEditor" />
+              <TiptapEditor
+                ref="editorRef"
+                :modelValue="body"
+                placeholder="Additional notes, wikilinks, context..."
+                @update:modelValue="onBodyUpdate"
+                @escape="titleRef?.focus()"
+              />
+            </div>
+          </div>
+        </template>
+
+        <!-- ── Generic note editor (existing) ───────────────────── -->
+        <template v-else-if="noteType === 'note'">
+          <!-- ... existing TipTap-first editor content stays here ... -->
+        </template>
+      </div>
+```
+
+IMPORTANT: Do NOT duplicate the existing editor content. Wrap the existing content in `<template v-else-if="noteType === 'note'">` and place the person form as a sibling `<template>` above it. The place and list forms will be added in subsequent tasks.
+
+- [ ] **Step 2: Add `notesExpanded` ref**
+
+In the `<script setup>`, after the `sidebarOpen` ref, add:
+
+```ts
+const notesExpanded = ref(false);
+```
+
+Also initialize it based on whether the note has body content, in the onMounted data-loading section. After `Object.assign(entityMeta, store.currentNote.metadata || {});` add:
+
+```ts
+      notesExpanded.value = !!(store.currentNote.body || '').trim();
+```
+
+- [ ] **Step 3: Remove person fields from sidebar**
+
+In the sidebar template, find:
+
+```html
+          <!-- Person metadata -->
+          <template v-if="noteType === 'person'">
+            <div class="sb-field">
+              <label class="sb-label">Relationship</label>
+              <input class="sb-input" v-model="entityMeta.relationship" placeholder="e.g. Friend, Colleague" @input="markDirty" />
+            </div>
+            <div class="sb-field">
+              <label class="sb-label">Email</label>
+              <input class="sb-input" v-model="entityMeta.email" type="email" placeholder="email@example.com" @input="markDirty" />
+            </div>
+            <div class="sb-field">
+              <label class="sb-label">Phone</label>
+              <input class="sb-input" v-model="entityMeta.phone" type="tel" placeholder="+1 555 000 0000" @input="markDirty" />
+            </div>
+          </template>
+```
+
+Delete this entire block.
+
+- [ ] **Step 4: Add entity form CSS**
+
+Add to the `<style scoped>` block:
+
+```css
+/* ── Entity form (Person / Place) ───────────────────────── */
+.entity-form {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 16px 0;
+}
+.ef-field {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.ef-label {
+  font-family: 'Fraunces', Georgia, serif;
+  font-style: italic;
+  font-size: 0.78rem;
+  color: var(--color-primary);
+}
+.ef-input {
+  padding: 8px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-surface);
+  color: var(--color-text);
+  font-size: 0.9rem;
+  font-family: inherit;
+  outline: none;
+  transition: border-color 0.15s;
+}
+.ef-input:focus {
+  border-color: var(--color-primary);
+  box-shadow: var(--focus-ring);
+}
+.ef-input::placeholder {
+  color: var(--color-text-muted);
+}
+
+/* ── Notes section (collapsible TipTap) ─────────────────── */
+.notes-section {
+  margin-top: 16px;
+  border-top: 1px solid var(--color-border);
+  padding-top: 12px;
+}
+.notes-toggle {
+  background: none;
+  border: none;
+  color: var(--color-primary);
+  font-family: 'Fraunces', Georgia, serif;
+  font-style: italic;
+  font-size: 0.85rem;
+  cursor: pointer;
+  padding: 4px 0;
+}
+.notes-toggle:hover {
+  color: var(--color-text);
+}
+.notes-editor-wrap {
+  margin-top: 8px;
+}
+```
+
+- [ ] **Step 5: Verify TypeScript compiles**
+
+```bash
+cd frontend && npx tsc --noEmit
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add frontend/src/views/NoteEditorView.vue
+git commit -m "feat(editor): person form-first layout with structured fields and collapsible notes"
+```
+
+---
+
+### Task 3: Place editor + List builder
+
+**Files:**
+- Modify: `frontend/src/views/NoteEditorView.vue`
+
+**Context:** Place uses the same entity form pattern as Person with different fields. List uses a dedicated checklist builder with Enter-to-add and Backspace-to-delete behavior. Both are additional `<template>` branches in the main column.
+
+- [ ] **Step 1: Add place form template**
+
+In the `note-main` div, after the person `</template>` and before the generic note `<template v-else-if="noteType === 'note'">`, add:
+
+```html
+        <!-- ── Place form ───────────────────────────────────────── -->
+        <template v-else-if="noteType === 'place'">
+          <div class="entity-form">
+            <div class="ef-field">
+              <label class="ef-label">Address</label>
+              <input class="ef-input" v-model="entityMeta.address" placeholder="Street, City, State" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Phone</label>
+              <input class="ef-input" type="tel" v-model="entityMeta.phone" placeholder="+1 555 000 0000" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Hours</label>
+              <input class="ef-input" v-model="entityMeta.hours" placeholder="e.g. Mon–Fri 9am–5pm" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Website</label>
+              <input class="ef-input" type="url" v-model="entityMeta.website" placeholder="https://..." @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Category</label>
+              <input class="ef-input" v-model="entityMeta.category" placeholder="e.g. Restaurant, Office, Doctor" @input="markDirty" />
+            </div>
+          </div>
+          <div class="notes-section">
+            <button class="notes-toggle" @click="notesExpanded = !notesExpanded">
+              {{ notesExpanded ? '▾' : '▸' }} Notes
+            </button>
+            <div v-if="notesExpanded" class="notes-editor-wrap">
+              <MarkdownToolbar v-show="!showPreview" :editor="tiptapEditor" />
+              <TiptapEditor
+                ref="editorRef"
+                :modelValue="body"
+                placeholder="Additional notes, wikilinks, context..."
+                @update:modelValue="onBodyUpdate"
+                @escape="titleRef?.focus()"
+              />
+            </div>
+          </div>
+        </template>
+```
+
+- [ ] **Step 2: Remove place fields from sidebar**
+
+Find and delete:
+
+```html
+          <!-- Place metadata -->
+          <template v-if="noteType === 'place'">
+            <div class="sb-field">
+              <label class="sb-label">Address</label>
+              <input class="sb-input" v-model="entityMeta.address" placeholder="Street, City" @input="markDirty" />
+            </div>
+            <div class="sb-field">
+              <label class="sb-label">Phone</label>
+              <input class="sb-input" v-model="entityMeta.phone" type="tel" placeholder="+1 555 000 0000" @input="markDirty" />
+            </div>
+            <div class="sb-field">
+              <label class="sb-label">Hours</label>
+              <input class="sb-input" v-model="entityMeta.hours" placeholder="e.g. Mon–Fri 9–5" @input="markDirty" />
+            </div>
+          </template>
+```
+
+- [ ] **Step 3: Add list item types and state**
+
+In the `<script setup>`, after the `notesExpanded` ref, add:
+
+```ts
+// ── List builder ─────────────────────────────────────────────────────────────
+interface ListItem {
+  text: string;
+  checked: boolean;
+}
+const listItems = ref<ListItem[]>([]);
+const listItemRefs = ref<(HTMLInputElement | null)[]>([]);
+
+function parseListFromBody(bodyText: string): { items: ListItem[]; extra: string } {
+  const lines = bodyText.split('\n');
+  const items: ListItem[] = [];
+  const extraLines: string[] = [];
+  let pastList = false;
+  for (const line of lines) {
+    const stripped = line.trimStart();
+    if (!pastList && (stripped.startsWith('- [ ] ') || stripped.startsWith('- [x] ') || stripped.startsWith('- [X] '))) {
+      items.push({ text: stripped.slice(6), checked: !stripped.startsWith('- [ ] ') });
+    } else if (!pastList && stripped === '' && items.length > 0) {
+      pastList = true;
+    } else {
+      pastList = true;
+      extraLines.push(line);
+    }
+  }
+  return { items, extra: extraLines.join('\n').trim() };
+}
+
+function serializeListToBody(): string {
+  const listPart = listItems.value
+    .map(item => `- [${item.checked ? 'x' : ' '}] ${item.text}`)
+    .join('\n');
+  const extraPart = body.value.trim();
+  return extraPart ? `${listPart}\n\n${extraPart}` : listPart;
+}
+
+function addListItem(afterIndex?: number) {
+  const idx = afterIndex !== undefined ? afterIndex + 1 : listItems.value.length;
+  listItems.value.splice(idx, 0, { text: '', checked: false });
+  markDirty();
+  nextTick(() => {
+    listItemRefs.value[idx]?.focus();
+  });
+}
+
+function removeListItem(index: number) {
+  if (listItems.value.length <= 1) return;
+  listItems.value.splice(index, 1);
+  markDirty();
+  nextTick(() => {
+    const focusIdx = Math.max(0, index - 1);
+    listItemRefs.value[focusIdx]?.focus();
+  });
+}
+
+function onListItemKeydown(e: KeyboardEvent, index: number) {
+  if (e.key === 'Enter') {
+    e.preventDefault();
+    addListItem(index);
+  } else if (e.key === 'Backspace' && listItems.value[index].text === '') {
+    e.preventDefault();
+    removeListItem(index);
+  }
+}
+
+function onListItemInput(index: number) {
+  markDirty();
+}
+
+function toggleListItemCheck(index: number) {
+  listItems.value[index].checked = !listItems.value[index].checked;
+  markDirty();
+}
+```
+
+- [ ] **Step 4: Initialize list items on mount**
+
+In the onMounted data-loading section, after `notesExpanded.value = !!(store.currentNote.body || '').trim();`, add:
+
+```ts
+      if (noteType.value === 'list') {
+        const parsed = parseListFromBody(body.value);
+        listItems.value = parsed.items.length > 0 ? parsed.items : [{ text: '', checked: false }];
+        body.value = parsed.extra;
+        notesExpanded.value = !!parsed.extra;
+      }
+```
+
+And in the new-note branch (the `else` block after loading), after `noteType.value = qt as NoteType;`, add:
+
+```ts
+    if (noteType.value === 'list') {
+      listItems.value = [{ text: '', checked: false }];
+    }
+```
+
+- [ ] **Step 5: Update save to serialize list**
+
+In the `save` function, find where the body is prepared for the API call. Before the `apiPost` or `apiPatch` call that sends the note data, add list serialization. Find the save function's data construction. Add before the API call:
+
+```ts
+  const finalBody = noteType.value === 'list' ? serializeListToBody() : body.value;
+```
+
+Then use `finalBody` instead of `body.value` in the API payload. Find all occurrences of `body: body.value` in the save function and replace with `body: finalBody`.
+
+- [ ] **Step 6: Add list builder template**
+
+In the `note-main` div, after the place `</template>` and before the generic note `<template v-else-if="noteType === 'note'">`, add:
+
+```html
+        <!-- ── List builder ─────────────────────────────────────── -->
+        <template v-else-if="noteType === 'list'">
+          <div class="list-builder">
+            <div
+              v-for="(item, idx) in listItems"
+              :key="idx"
+              class="lb-item"
+            >
+              <input
+                type="checkbox"
+                :checked="item.checked"
+                @change="toggleListItemCheck(idx)"
+                class="lb-check"
+                tabindex="-1"
+              />
+              <input
+                :ref="(el) => { listItemRefs[idx] = el as HTMLInputElement | null }"
+                v-model="item.text"
+                class="lb-text"
+                placeholder="List item..."
+                @keydown="onListItemKeydown($event, idx)"
+                @input="onListItemInput(idx)"
+              />
+              <button class="lb-delete" tabindex="-1" @click="removeListItem(idx)" title="Remove item">&times;</button>
+            </div>
+            <button class="lb-add" @click="addListItem()">+ Add item</button>
+          </div>
+          <div class="notes-section">
+            <button class="notes-toggle" @click="notesExpanded = !notesExpanded">
+              {{ notesExpanded ? '▾' : '▸' }} Notes
+            </button>
+            <div v-if="notesExpanded" class="notes-editor-wrap">
+              <MarkdownToolbar v-show="!showPreview" :editor="tiptapEditor" />
+              <TiptapEditor
+                ref="editorRef"
+                :modelValue="body"
+                placeholder="Additional notes, context..."
+                @update:modelValue="onBodyUpdate"
+                @escape="titleRef?.focus()"
+              />
+            </div>
+          </div>
+        </template>
+```
+
+- [ ] **Step 7: Add list builder CSS**
+
+Add to the `<style scoped>` block:
+
+```css
+/* ── List builder ───────────────────────────────────────── */
+.list-builder {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 12px 0;
+}
+.lb-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.lb-check {
+  flex-shrink: 0;
+  width: 18px;
+  height: 18px;
+  accent-color: var(--color-primary);
+  cursor: pointer;
+}
+.lb-text {
+  flex: 1;
+  padding: 7px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-surface);
+  color: var(--color-text);
+  font-size: 0.9rem;
+  font-family: inherit;
+  outline: none;
+  transition: border-color 0.15s;
+}
+.lb-text:focus {
+  border-color: var(--color-primary);
+  box-shadow: var(--focus-ring);
+}
+.lb-text::placeholder {
+  color: var(--color-text-muted);
+}
+.lb-delete {
+  background: none;
+  border: none;
+  color: var(--color-text-muted);
+  font-size: 1.1rem;
+  cursor: pointer;
+  padding: 0 4px;
+  line-height: 1;
+  opacity: 0;
+  transition: opacity 0.12s, color 0.12s;
+}
+.lb-item:hover .lb-delete,
+.lb-text:focus ~ .lb-delete {
+  opacity: 1;
+}
+.lb-delete:hover {
+  color: var(--color-danger);
+}
+.lb-add {
+  background: none;
+  border: 1px dashed var(--color-border);
+  border-radius: 8px;
+  padding: 7px 12px;
+  color: var(--color-text-muted);
+  font-size: 0.85rem;
+  cursor: pointer;
+  margin-top: 4px;
+  transition: border-color 0.15s, color 0.15s;
+}
+.lb-add:hover {
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+}
+```
+
+- [ ] **Step 8: Handle the generic note template wrapper**
+
+Make sure the existing TipTap-first editor content is wrapped in `<template v-else>` (not `v-else-if="noteType === 'note'"`) so it serves as the default for any unrecognized type.
+
+The final structure in `.note-main` should be:
+
+```
+<template v-if="noteType === 'person'"> ... </template>
+<template v-else-if="noteType === 'place'"> ... </template>
+<template v-else-if="noteType === 'list'"> ... </template>
+<template v-else> ... existing TipTap editor ... </template>
+```
+
+- [ ] **Step 9: Verify TypeScript compiles**
+
+```bash
+cd frontend && npx tsc --noEmit
+```
+
+- [ ] **Step 10: Commit**
+
+```bash
+git add frontend/src/views/NoteEditorView.vue
+git commit -m "feat(editor): place form-first layout and list builder with Enter-to-add"
+```
+
+---
+
+### Task 4: Backend — new person/place fields in knowledge cards
+
+**Files:**
+- Modify: `src/fabledassistant/services/knowledge.py`
+- Modify: `frontend/src/views/KnowledgeView.vue`
+
+**Context:** The knowledge card display should show the new fields (birthday, organization for person; website, category for place). The backend `_note_to_item` needs to include them. The frontend card rendering needs to display the useful ones.
+
+- [ ] **Step 1: Update `_note_to_item` for person**
+
+In `src/fabledassistant/services/knowledge.py`, find:
+
+```python
+    if note.entity_type == "person":
+        item["relationship"] = meta.get("relationship", "")
+        item["email"] = meta.get("email", "")
+        item["phone"] = meta.get("phone", "")
+```
+
+Replace with:
+
+```python
+    if note.entity_type == "person":
+        item["relationship"] = meta.get("relationship", "")
+        item["email"] = meta.get("email", "")
+        item["phone"] = meta.get("phone", "")
+        item["birthday"] = meta.get("birthday", "")
+        item["organization"] = meta.get("organization", "")
+        item["address"] = meta.get("address", "")
+```
+
+- [ ] **Step 2: Update `_note_to_item` for place**
+
+Find:
+
+```python
+    elif note.entity_type == "place":
+        item["address"] = meta.get("address", "")
+        item["phone"] = meta.get("phone", "")
+        item["hours"] = meta.get("hours", "")
+```
+
+Replace with:
+
+```python
+    elif note.entity_type == "place":
+        item["address"] = meta.get("address", "")
+        item["phone"] = meta.get("phone", "")
+        item["hours"] = meta.get("hours", "")
+        item["website"] = meta.get("website", "")
+        item["category"] = meta.get("category", "")
+```
+
+- [ ] **Step 3: Update KnowledgeItem interface**
+
+In `frontend/src/views/KnowledgeView.vue`, find the `KnowledgeItem` interface and add the new fields:
+
+After `phone?: string;` add:
+```ts
+  birthday?: string;
+  organization?: string;
+```
+
+After `hours?: string;` add:
+```ts
+  website?: string;
+  category?: string;
+```
+
+- [ ] **Step 4: Update person card display**
+
+In the template, find the person card specifics:
+
+```html
+              <div v-if="item.note_type === 'person'" class="k-card-meta">
+                <span v-if="item.relationship" class="meta-chip">{{ item.relationship }}</span>
+                <span v-if="item.phone" class="meta-muted">{{ item.phone }}</span>
+              </div>
+```
+
+Replace with:
+
+```html
+              <div v-if="item.note_type === 'person'" class="k-card-meta">
+                <span v-if="item.relationship" class="meta-chip">{{ item.relationship }}</span>
+                <span v-if="item.organization" class="meta-muted">{{ item.organization }}</span>
+                <span v-if="item.phone" class="meta-muted">{{ item.phone }}</span>
+              </div>
+```
+
+- [ ] **Step 5: Update place card display**
+
+Find:
+
+```html
+              <div v-else-if="item.note_type === 'place'" class="k-card-meta">
+                <span v-if="item.address" class="meta-muted">{{ item.address }}</span>
+                <span v-if="item.hours" class="meta-muted">{{ item.hours }}</span>
+              </div>
+```
+
+Replace with:
+
+```html
+              <div v-else-if="item.note_type === 'place'" class="k-card-meta">
+                <span v-if="item.category" class="meta-chip">{{ item.category }}</span>
+                <span v-if="item.address" class="meta-muted">{{ item.address }}</span>
+                <span v-if="item.hours" class="meta-muted">{{ item.hours }}</span>
+              </div>
+```
+
+- [ ] **Step 6: Verify TypeScript compiles and backend syntax**
+
+```bash
+cd frontend && npx tsc --noEmit
+python -c "import ast; ast.parse(open('src/fabledassistant/services/knowledge.py').read()); print('OK')"
+```
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/fabledassistant/services/knowledge.py frontend/src/views/KnowledgeView.vue
+git commit -m "feat(knowledge): show organization/birthday for person cards, category for place cards"
+```

docs/superpowers/plans/2026-04-17-unified-lookup-wikipedia.md

@@ -0,0 +1,782 @@
+# Unified Lookup Tool & Wikipedia Integration — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace `search_web` with a unified `lookup` tool (Wikipedia-first, SearXNG fallback) and add Wikipedia as a source in the research pipeline.
+
+**Architecture:** New `wikipedia.py` service with `wiki_summary` and `wiki_search`. `lookup` tool in `web.py` replaces `search_web`. Research pipeline in `research.py` gains Wikipedia sources alongside SearXNG. All `search_web` references across the codebase are updated.
+
+**Tech Stack:** Python 3.12, httpx, pytest, asyncio
+
+---
+
+### Task 1: Wikipedia Service Module
+
+**Files:**
+- Create: `src/fabledassistant/services/wikipedia.py`
+- Create: `tests/test_wikipedia.py`
+
+- [ ] **Step 1: Write failing tests for `wiki_summary`**
+
+```python
+# tests/test_wikipedia.py
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import httpx
+
+
+@pytest.mark.asyncio
+async def test_wiki_summary_returns_extract():
+    from fabledassistant.services.wikipedia import wiki_summary
+
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "type": "standard",
+        "title": "Python (programming language)",
+        "extract": "Python is a high-level programming language.",
+        "content_urls": {
+            "desktop": {"page": "https://en.wikipedia.org/wiki/Python_(programming_language)"}
+        },
+    }
+    mock_response.raise_for_status = MagicMock()
+
+    with patch("fabledassistant.services.wikipedia.httpx.AsyncClient") as mock_client_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.get = AsyncMock(return_value=mock_response)
+        mock_client_cls.return_value = mock_client
+
+        result = await wiki_summary("Python programming language")
+
+    assert result is not None
+    assert result["title"] == "Python (programming language)"
+    assert "high-level" in result["extract"]
+    assert "wikipedia.org" in result["url"]
+
+
+@pytest.mark.asyncio
+async def test_wiki_summary_returns_none_on_404():
+    from fabledassistant.services.wikipedia import wiki_summary
+
+    with patch("fabledassistant.services.wikipedia.httpx.AsyncClient") as mock_client_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.get = AsyncMock(side_effect=httpx.HTTPStatusError(
+            "Not Found", request=MagicMock(), response=MagicMock(status_code=404)
+        ))
+        mock_client_cls.return_value = mock_client
+
+        result = await wiki_summary("xyznonexistenttopic123")
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_wiki_summary_returns_none_on_disambiguation():
+    from fabledassistant.services.wikipedia import wiki_summary
+
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "type": "disambiguation",
+        "title": "Python",
+        "extract": "Python may refer to...",
+    }
+    mock_response.raise_for_status = MagicMock()
+
+    with patch("fabledassistant.services.wikipedia.httpx.AsyncClient") as mock_client_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.get = AsyncMock(return_value=mock_response)
+        mock_client_cls.return_value = mock_client
+
+        result = await wiki_summary("Python")
+
+    assert result is None
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_wikipedia.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'fabledassistant.services.wikipedia'`
+
+- [ ] **Step 3: Implement `wiki_summary`**
+
+```python
+# src/fabledassistant/services/wikipedia.py
+"""Wikipedia API: lightweight topic lookups and article search."""
+
+import logging
+from urllib.parse import quote as url_quote
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_SUMMARY_URL = "https://en.wikipedia.org/api/rest_v1/page/summary"
+_SEARCH_URL = "https://en.wikipedia.org/w/api.php"
+_TIMEOUT = 5.0
+_USER_AGENT = "FabledAssistant/1.0 (https://fabledsword.com)"
+
+
+async def wiki_summary(query: str) -> dict | None:
+    """Look up a topic by title via the Wikipedia REST summary endpoint.
+
+    Returns {"title", "extract", "url"} on hit, None on miss.
+    """
+    encoded = url_quote(query.replace(" ", "_"), safe="")
+    try:
+        async with httpx.AsyncClient(
+            timeout=_TIMEOUT, headers={"User-Agent": _USER_AGENT}
+        ) as client:
+            resp = await client.get(f"{_SUMMARY_URL}/{encoded}", follow_redirects=True)
+            resp.raise_for_status()
+            data = resp.json()
+    except Exception:
+        logger.debug("Wikipedia summary lookup failed for %r", query, exc_info=True)
+        return None
+
+    if data.get("type") == "disambiguation":
+        return None
+
+    extract = data.get("extract", "").strip()
+    if not extract:
+        return None
+
+    url = (
+        data.get("content_urls", {}).get("desktop", {}).get("page")
+        or f"https://en.wikipedia.org/wiki/{encoded}"
+    )
+    return {"title": data.get("title", query), "extract": extract, "url": url}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_wikipedia.py -v`
+Expected: 3 passed
+
+- [ ] **Step 5: Write failing tests for `wiki_search`**
+
+Add to `tests/test_wikipedia.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_wiki_search_returns_results():
+    from fabledassistant.services.wikipedia import wiki_search
+
+    search_response = MagicMock()
+    search_response.status_code = 200
+    search_response.json.return_value = {
+        "query": {
+            "search": [
+                {"title": "QUIC"},
+                {"title": "HTTP/3"},
+            ]
+        }
+    }
+    search_response.raise_for_status = MagicMock()
+
+    summary_response = MagicMock()
+    summary_response.status_code = 200
+    summary_response.json.return_value = {
+        "type": "standard",
+        "title": "QUIC",
+        "extract": "QUIC is a transport layer protocol.",
+        "content_urls": {"desktop": {"page": "https://en.wikipedia.org/wiki/QUIC"}},
+    }
+    summary_response.raise_for_status = MagicMock()
+
+    with patch("fabledassistant.services.wikipedia.httpx.AsyncClient") as mock_client_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.get = AsyncMock(side_effect=[search_response, summary_response, summary_response])
+        mock_client_cls.return_value = mock_client
+
+        results = await wiki_search("QUIC protocol", limit=2)
+
+    assert len(results) >= 1
+    assert results[0]["title"] == "QUIC"
+    assert "transport" in results[0]["extract"]
+
+
+@pytest.mark.asyncio
+async def test_wiki_search_returns_empty_on_failure():
+    from fabledassistant.services.wikipedia import wiki_search
+
+    with patch("fabledassistant.services.wikipedia.httpx.AsyncClient") as mock_client_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.get = AsyncMock(side_effect=httpx.ConnectError("connection failed"))
+        mock_client_cls.return_value = mock_client
+
+        results = await wiki_search("anything")
+
+    assert results == []
+```
+
+- [ ] **Step 6: Implement `wiki_search`**
+
+Add to `src/fabledassistant/services/wikipedia.py`:
+
+```python
+async def wiki_search(query: str, limit: int = 3) -> list[dict]:
+    """Search Wikipedia for articles matching a query.
+
+    Returns [{"title", "extract", "url"}, ...] (may be empty).
+    """
+    try:
+        async with httpx.AsyncClient(
+            timeout=_TIMEOUT, headers={"User-Agent": _USER_AGENT}
+        ) as client:
+            resp = await client.get(_SEARCH_URL, params={
+                "action": "query",
+                "list": "search",
+                "srsearch": query,
+                "srlimit": str(limit),
+                "format": "json",
+            })
+            resp.raise_for_status()
+            hits = resp.json().get("query", {}).get("search", [])
+            if not hits:
+                return []
+
+            results: list[dict] = []
+            for hit in hits:
+                title = hit.get("title", "")
+                if not title:
+                    continue
+                encoded = url_quote(title.replace(" ", "_"), safe="")
+                try:
+                    summary_resp = await client.get(
+                        f"{_SUMMARY_URL}/{encoded}", follow_redirects=True,
+                    )
+                    summary_resp.raise_for_status()
+                    data = summary_resp.json()
+                except Exception:
+                    continue
+                if data.get("type") == "disambiguation":
+                    continue
+                extract = data.get("extract", "").strip()
+                if not extract:
+                    continue
+                url = (
+                    data.get("content_urls", {}).get("desktop", {}).get("page")
+                    or f"https://en.wikipedia.org/wiki/{encoded}"
+                )
+                results.append({"title": data.get("title", title), "extract": extract, "url": url})
+            return results
+    except Exception:
+        logger.debug("Wikipedia search failed for %r", query, exc_info=True)
+        return []
+```
+
+- [ ] **Step 7: Run all wikipedia tests**
+
+Run: `uv run pytest tests/test_wikipedia.py -v`
+Expected: 5 passed
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src/fabledassistant/services/wikipedia.py tests/test_wikipedia.py
+git commit -m "feat: add wikipedia service with summary lookup and search"
+```
+
+---
+
+### Task 2: Lookup Tool (replaces search_web)
+
+**Files:**
+- Modify: `src/fabledassistant/services/tools/web.py`
+- Create: `tests/test_lookup_tool.py`
+
+- [ ] **Step 1: Write failing tests for `lookup`**
+
+```python
+# tests/test_lookup_tool.py
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+
+
+@pytest.mark.asyncio
+async def test_lookup_wikipedia_hit():
+    """lookup returns wikipedia source when wiki_summary succeeds."""
+    wiki_data = {
+        "title": "QUIC",
+        "extract": "QUIC is a transport layer protocol.",
+        "url": "https://en.wikipedia.org/wiki/QUIC",
+    }
+
+    with patch("fabledassistant.services.tools.web.wiki_summary", new_callable=AsyncMock, return_value=wiki_data):
+        from fabledassistant.services.tools.web import lookup_tool
+        result = await lookup_tool(user_id=1, arguments={"query": "QUIC"})
+
+    assert result["success"] is True
+    assert result["type"] == "lookup"
+    assert result["source"] == "wikipedia"
+    assert result["data"]["title"] == "QUIC"
+    assert "transport" in result["data"]["extract"]
+
+
+@pytest.mark.asyncio
+async def test_lookup_wikipedia_miss_searxng_fallback():
+    """lookup falls back to SearXNG + article fetch when Wikipedia misses."""
+    searxng_results = [
+        {"url": "https://example.com/quic", "title": "QUIC Explained", "snippet": "An overview..."},
+    ]
+
+    with patch("fabledassistant.services.tools.web.wiki_summary", new_callable=AsyncMock, return_value=None), \
+         patch("fabledassistant.services.tools.web.Config") as mock_config, \
+         patch("fabledassistant.services.tools.web._search_searxng", new_callable=AsyncMock, return_value=searxng_results), \
+         patch("fabledassistant.services.tools.web._fetch_full_article", new_callable=AsyncMock, return_value="Full article about QUIC..."):
+        mock_config.searxng_enabled.return_value = True
+        from fabledassistant.services.tools.web import lookup_tool
+        result = await lookup_tool(user_id=1, arguments={"query": "QUIC"})
+
+    assert result["success"] is True
+    assert result["type"] == "lookup"
+    assert result["source"] == "web"
+    assert result["data"]["results"]
+
+
+@pytest.mark.asyncio
+async def test_lookup_wikipedia_miss_no_searxng():
+    """lookup returns no-results when Wikipedia misses and SearXNG is not configured."""
+    with patch("fabledassistant.services.tools.web.wiki_summary", new_callable=AsyncMock, return_value=None), \
+         patch("fabledassistant.services.tools.web.Config") as mock_config:
+        mock_config.searxng_enabled.return_value = False
+        from fabledassistant.services.tools.web import lookup_tool
+        result = await lookup_tool(user_id=1, arguments={"query": "xyznonexistent"})
+
+    assert result["success"] is True
+    assert result["source"] == "none"
+
+
+@pytest.mark.asyncio
+async def test_lookup_always_available():
+    """lookup tool must appear in get_tools_for_user regardless of SearXNG config."""
+    with patch("fabledassistant.services.tools._registry.is_caldav_configured", new_callable=AsyncMock, return_value=False), \
+         patch("fabledassistant.services.settings.get_setting", new_callable=AsyncMock, return_value="false"):
+        from fabledassistant.services.tools import get_tools_for_user
+        tools = await get_tools_for_user(user_id=1)
+        tool_names = {t["function"]["name"] for t in tools}
+        assert "lookup" in tool_names
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_lookup_tool.py -v`
+Expected: FAIL (no `lookup_tool` function)
+
+- [ ] **Step 3: Replace `search_web` with `lookup` in `web.py`**
+
+Replace the `search_web_tool` function (lines 12–36 of `src/fabledassistant/services/tools/web.py`) with:
+
+```python
+@tool(
+    name="lookup",
+    description=(
+        "Look up a topic, concept, or factual question. Returns a concise answer from "
+        "Wikipedia or web sources. Use for definitions, explanations, 'what is X', "
+        "'how does Y work', current events, or version numbers. No note is saved. "
+        "For comprehensive written reports saved as notes, use research_topic instead."
+    ),
+    parameters={
+        "query": {"type": "string", "description": "The topic or question to look up"},
+    },
+    required=["query"],
+)
+async def lookup_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.config import Config
+    from fabledassistant.services.wikipedia import wiki_summary
+
+    query = arguments.get("query", "")
+
+    # 1. Try Wikipedia first
+    wiki = await wiki_summary(query)
+    if wiki:
+        return {
+            "success": True,
+            "type": "lookup",
+            "source": "wikipedia",
+            "data": wiki,
+        }
+
+    # 2. Fall back to SearXNG + article fetch
+    if Config.searxng_enabled():
+        from fabledassistant.services.research import _search_searxng
+        from fabledassistant.services.rss import _fetch_full_article
+
+        results = await _search_searxng(query)
+        if results:
+            articles: list[dict] = []
+            for r in results[:2]:
+                url = r.get("url", "")
+                if not url:
+                    continue
+                content = await _fetch_full_article(url)
+                articles.append({
+                    "url": url,
+                    "title": r.get("title", url),
+                    "snippet": r.get("snippet", ""),
+                    "content": (content or "")[:4000],
+                })
+            if articles:
+                return {
+                    "success": True,
+                    "type": "lookup",
+                    "source": "web",
+                    "data": {"query": query, "results": articles},
+                }
+
+    # 3. No sources available
+    return {
+        "success": True,
+        "type": "lookup",
+        "source": "none",
+        "data": {
+            "query": query,
+            "message": "No results found. You can answer from your own knowledge.",
+        },
+    }
+```
+
+- [ ] **Step 4: Run lookup tests to verify they pass**
+
+Run: `uv run pytest tests/test_lookup_tool.py -v`
+Expected: 4 passed
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/fabledassistant/services/tools/web.py tests/test_lookup_tool.py
+git commit -m "feat: replace search_web with unified lookup tool (Wikipedia + SearXNG fallback)"
+```
+
+---
+
+### Task 3: Update All `search_web` References
+
+**Files:**
+- Modify: `src/fabledassistant/services/tools/web.py:45` (research_topic description)
+- Modify: `src/fabledassistant/services/tools/web.py:67` (search_images description)
+- Modify: `src/fabledassistant/services/tools/rss.py:75` (read_article description)
+- Modify: `src/fabledassistant/services/generation_task.py:133` (status label map)
+- Modify: `src/fabledassistant/services/llm.py:608` (action list)
+
+- [ ] **Step 1: Update `research_topic` description**
+
+In `src/fabledassistant/services/tools/web.py`, change the `research_topic` description from:
+
+```python
+        "For a quick factual answer without saving a note, use search_web."
+```
+
+to:
+
+```python
+        "For a quick factual answer without saving a note, use lookup."
+```
+
+- [ ] **Step 2: Update `search_images` description**
+
+In `src/fabledassistant/services/tools/web.py`, change the `search_images` description from:
+
+```python
+    description="Search and display images inline. Use ONLY when the user explicitly asks to see, show, or find an image or photo. Not for factual questions — use search_web for those.",
+```
+
+to:
+
+```python
+    description="Search and display images inline. Use ONLY when the user explicitly asks to see, show, or find an image or photo. Not for factual questions — use lookup for those.",
+```
+
+- [ ] **Step 3: Update `read_article` description**
+
+In `src/fabledassistant/services/tools/rss.py`, change:
+
+```python
+        "Do NOT use search_web for URLs — use this tool instead."
+```
+
+to:
+
+```python
+        "Do NOT use lookup for URLs — use this tool instead."
+```
+
+- [ ] **Step 4: Update status label map in `generation_task.py`**
+
+In `src/fabledassistant/services/generation_task.py`, line 133, change:
+
+```python
+    "search_web": "Searching the web",
+```
+
+to:
+
+```python
+    "lookup": "Looking up information",
+```
+
+- [ ] **Step 5: Update action list in `llm.py`**
+
+In `src/fabledassistant/services/llm.py`, line 608, change:
+
+```python
+        actions.extend(["search_web", "research_topic", "search_images"])
+```
+
+to:
+
+```python
+        actions.extend(["lookup", "research_topic", "search_images"])
+```
+
+- [ ] **Step 6: Run full test suite to check for regressions**
+
+Run: `uv run pytest tests/ -v`
+Expected: All tests pass (no test references `search_web` by name in assertions)
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/fabledassistant/services/tools/web.py src/fabledassistant/services/tools/rss.py src/fabledassistant/services/generation_task.py src/fabledassistant/services/llm.py
+git commit -m "refactor: update all search_web references to lookup"
+```
+
+---
+
+### Task 4: Add Wikipedia Sources to Research Pipeline
+
+**Files:**
+- Modify: `src/fabledassistant/services/research.py`
+- Modify: `tests/test_research_pipeline.py`
+
+- [ ] **Step 1: Write failing test for Wikipedia in research pipeline**
+
+Add to `tests/test_research_pipeline.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_pipeline_includes_wikipedia_sources():
+    """run_research_pipeline should merge Wikipedia results into the source pool."""
+    from unittest.mock import MagicMock
+
+    wiki_results = [{"title": "Wiki Article", "extract": "Wikipedia content about the topic.", "url": "https://en.wikipedia.org/wiki/Topic"}]
+
+    outline = [
+        {"title": "Section A", "focus": "Focus A"},
+        {"title": "Section B", "focus": "Focus B"},
+    ]
+
+    note_id_counter = iter(range(30, 40))
+
+    def _make_note(user_id, title, body, tags, project_id=None, parent_id=None):
+        n = MagicMock()
+        n.id = next(note_id_counter)
+        n.title = title
+        return n
+
+    with patch("fabledassistant.services.research._generate_sub_queries", new_callable=AsyncMock, return_value=["q1"]), \
+         patch("fabledassistant.services.research._search_searxng", new_callable=AsyncMock, return_value=[{"url": "http://x.com", "title": "X", "snippet": "s"}]), \
+         patch("fabledassistant.services.research.wiki_search", new_callable=AsyncMock, return_value=wiki_results), \
+         patch("fabledassistant.services.research.fetch_url_content", new_callable=AsyncMock, return_value="content"), \
+         patch("fabledassistant.services.research._generate_outline", new_callable=AsyncMock, return_value=outline) as mock_outline, \
+         patch("fabledassistant.services.research._synthesize_section", new_callable=AsyncMock, side_effect=lambda t, f, s, m: (t, f"Body for {t}")), \
+         patch("fabledassistant.services.research._generate_executive_summary", new_callable=AsyncMock, return_value="Summary."), \
+         patch("fabledassistant.services.research.create_note", new_callable=AsyncMock, side_effect=_make_note), \
+         patch("fabledassistant.services.research.update_note", new_callable=AsyncMock):
+
+        from fabledassistant.services.research import run_research_pipeline
+        await run_research_pipeline("test topic", user_id=1, model="test-model")
+
+    # The sources passed to _generate_outline should include the Wikipedia article
+    sources_arg = mock_outline.call_args[0][1]  # second positional arg
+    source_urls = [s["url"] for s in sources_arg]
+    assert "https://en.wikipedia.org/wiki/Topic" in source_urls
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_research_pipeline.py::test_pipeline_includes_wikipedia_sources -v`
+Expected: FAIL (no `wiki_search` import in research.py)
+
+- [ ] **Step 3: Add Wikipedia sources to the research pipeline**
+
+In `src/fabledassistant/services/research.py`, add the import at the top (after existing imports):
+
+```python
+from fabledassistant.services.wikipedia import wiki_search
+```
+
+Then modify Step 2 (the parallel search section, around lines 208–246). Replace:
+
+```python
+    # Step 2: Search all queries in parallel (200 ms stagger to avoid hammering SearXNG)
+    async def _search_with_stagger(i: int, query: str) -> tuple[str, list[dict]]:
+        if i > 0:
+            await asyncio.sleep(0.2 * i)
+        _status(f"Searching: {query}...")
+        results = await _search_searxng(query)
+        logger.info("Research: query '%s' → %d results", query, len(results))
+        return query, results
+
+    search_results = await asyncio.gather(
+        *[_search_with_stagger(i, q) for i, q in enumerate(queries)]
+    )
+
+    # Deduplicate URLs across all queries
+    seen_urls: set[str] = set()
+    url_tasks: list[tuple[str, dict, str]] = []  # (url, result_dict, query)
+    for query, results in search_results:
+        for result in results[:PAGES_PER_QUERY]:
+            url = result.get("url", "")
+            if url and url not in seen_urls:
+                seen_urls.add(url)
+                url_tasks.append((url, result, query))
+
+    # Fetch all unique URLs in parallel
+    async def _fetch_source(url: str, result: dict, query: str) -> dict:
+        title = result.get("title", url)
+        _status(f"Reading: {title[:60]}...")
+        content = await fetch_url_content(url)
+        return {
+            "url": url,
+            "title": title,
+            "query": query,
+            "snippet": result.get("snippet", ""),
+            "content": content,
+        }
+
+    all_sources: list[dict] = list(await asyncio.gather(
+        *[_fetch_source(url, result, query) for url, result, query in url_tasks]
+    ))
+```
+
+with:
+
+```python
+    # Step 2: Search all queries in parallel (SearXNG + Wikipedia)
+    async def _search_with_stagger(i: int, query: str) -> tuple[str, list[dict]]:
+        if i > 0:
+            await asyncio.sleep(0.2 * i)
+        _status(f"Searching: {query}...")
+        results = await _search_searxng(query)
+        logger.info("Research: query '%s' → %d results", query, len(results))
+        return query, results
+
+    async def _wiki_for_query(query: str) -> list[dict]:
+        return await wiki_search(query, limit=1)
+
+    searxng_task = asyncio.gather(
+        *[_search_with_stagger(i, q) for i, q in enumerate(queries)]
+    )
+    wiki_task = asyncio.gather(
+        *[_wiki_for_query(q) for q in queries]
+    )
+    search_results, wiki_results = await asyncio.gather(searxng_task, wiki_task)
+
+    # Deduplicate URLs across all queries
+    seen_urls: set[str] = set()
+    url_tasks: list[tuple[str, dict, str]] = []  # (url, result_dict, query)
+    wiki_sources: list[dict] = []  # Wikipedia articles (already have content)
+
+    for query, results in search_results:
+        for result in results[:PAGES_PER_QUERY]:
+            url = result.get("url", "")
+            if url and url not in seen_urls:
+                seen_urls.add(url)
+                url_tasks.append((url, result, query))
+
+    # Add Wikipedia results (they already have content via extract)
+    for query, wiki_hits in zip(queries, wiki_results):
+        for hit in wiki_hits:
+            url = hit.get("url", "")
+            if url and url not in seen_urls:
+                seen_urls.add(url)
+                wiki_sources.append({
+                    "url": url,
+                    "title": hit["title"],
+                    "query": query,
+                    "snippet": hit["extract"][:200],
+                    "content": hit["extract"],
+                })
+
+    # Fetch all unique SearXNG URLs in parallel
+    async def _fetch_source(url: str, result: dict, query: str) -> dict:
+        title = result.get("title", url)
+        _status(f"Reading: {title[:60]}...")
+        content = await fetch_url_content(url)
+        return {
+            "url": url,
+            "title": title,
+            "query": query,
+            "snippet": result.get("snippet", ""),
+            "content": content,
+        }
+
+    fetched_sources: list[dict] = list(await asyncio.gather(
+        *[_fetch_source(url, result, query) for url, result, query in url_tasks]
+    ))
+
+    all_sources = wiki_sources + fetched_sources
+```
+
+- [ ] **Step 4: Run the new test to verify it passes**
+
+Run: `uv run pytest tests/test_research_pipeline.py::test_pipeline_includes_wikipedia_sources -v`
+Expected: PASS
+
+- [ ] **Step 5: Run the full research test suite for regressions**
+
+Run: `uv run pytest tests/test_research_pipeline.py -v`
+Expected: All tests pass
+
+- [ ] **Step 6: Run full test suite**
+
+Run: `uv run pytest tests/ -v`
+Expected: All tests pass
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/fabledassistant/services/research.py tests/test_research_pipeline.py
+git commit -m "feat: add Wikipedia as research pipeline source alongside SearXNG"
+```
+
+---
+
+### Task 5: Lint, Typecheck, Final Verification
+
+**Files:**
+- All modified files
+
+- [ ] **Step 1: Run ruff lint**
+
+Run: `uv run ruff check src/fabledassistant/services/wikipedia.py src/fabledassistant/services/tools/web.py src/fabledassistant/services/research.py tests/test_wikipedia.py tests/test_lookup_tool.py`
+Expected: All checks passed (fix any issues if not)
+
+- [ ] **Step 2: Run typecheck**
+
+Run: `cd frontend && npx vue-tsc --noEmit` (frontend unchanged, but verify nothing broke)
+Expected: Clean
+
+- [ ] **Step 3: Run full test suite one last time**
+
+Run: `uv run pytest tests/ -v`
+Expected: All tests pass
+
+- [ ] **Step 4: Commit any lint fixes if needed**
+
+```bash
+git add -u
+git commit -m "fix: lint cleanup for lookup/wikipedia changes"
+```

docs/superpowers/specs/2026-04-08-note-type-editors.md

@@ -0,0 +1,204 @@
+# Specialized Note Type Editors — Design Spec
+
+## Goal
+
+Replace the one-size-fits-all note editor with type-specialized views for Person, Place, and List. Each type gets a form-first layout where structured fields are the main content, with a secondary notes area for free text. Fix tab navigation across all note types so focus flows logically from title through fields to body, skipping the formatting toolbar.
+
+## Architecture
+
+The existing `NoteEditorView.vue` remains the single editor component but renders different layouts based on `noteType`. When `noteType` is `person`, `place`, or `list`, the main editor area switches from TipTap-first to form-first. The TipTap editor moves to a secondary "Notes" section below the form fields. The sidebar metadata fields for person/place move into the main content area. The `note_type` field, entity metadata storage, and API contract are unchanged.
+
+## Person Editor
+
+When `noteType === 'person'`, the main content area renders a contact card form instead of the TipTap editor.
+
+### Fields (in order, all in main content area)
+
+| Field | Type | Placeholder | Source |
+|-------|------|-------------|--------|
+| Name | text input (title) | "Name" | `title` |
+| Relationship | text input | "e.g. Friend, Colleague, Family" | `entityMeta.relationship` |
+| Birthday | date input | — | `entityMeta.birthday` (new field) |
+| Email | email input | "email@example.com" | `entityMeta.email` |
+| Phone | tel input | "+1 555 000 0000" | `entityMeta.phone` |
+| Organization | text input | "Company or organization" | `entityMeta.organization` (new field) |
+| Address | text input | "Street, City, State" | `entityMeta.address` (new field for person) |
+
+### Notes section
+
+Below the form fields, a collapsible "Notes" section with the TipTap editor for free-text content. This is where wikilinks, tags, and general context go. The section starts expanded if the note already has body content, collapsed if empty on a new note.
+
+### Layout
+
+```
+┌──────────────────────────────────────────┐
+│ [← Knowledge]  [Save]  [Delete]          │
+│                                          │
+│ Name: [________________________________] │
+│                                          │
+│ Relationship: [________________________] │
+│ Birthday:     [____date picker________]  │
+│ Email:        [________________________] │
+│ Phone:        [________________________] │
+│ Organization: [________________________] │
+│ Address:      [________________________] │
+│                                          │
+│ ▾ Notes                                  │
+│ ┌──────────────────────────────────────┐ │
+│ │ TipTap editor (markdown body)       │ │
+│ └──────────────────────────────────────┘ │
+│                                          │
+│           [sidebar: project/tags/etc]    │
+└──────────────────────────────────────────┘
+```
+
+### Data migration
+
+Existing person notes may have structured data written as plain text in the body (e.g. "Relationship: daughter Birthday: 2013-12-13"). No automatic migration — the body content stays as-is in the Notes section. Users can move data to the structured fields manually.
+
+## Place Editor
+
+When `noteType === 'place'`, same form-first pattern.
+
+### Fields
+
+| Field | Type | Placeholder | Source |
+|-------|------|-------------|--------|
+| Name | text input (title) | "Place name" | `title` |
+| Address | text input | "Street, City, State" | `entityMeta.address` |
+| Phone | tel input | "+1 555 000 0000" | `entityMeta.phone` |
+| Hours | text input | "e.g. Mon–Fri 9am–5pm" | `entityMeta.hours` |
+| Website | url input | "https://..." | `entityMeta.website` (new field) |
+| Category | text input | "e.g. Restaurant, Office, Doctor" | `entityMeta.category` (new field) |
+
+### Notes section
+
+Same as Person — collapsible TipTap editor below the form.
+
+## List Editor
+
+When `noteType === 'list'`, the main content area renders a checklist builder instead of the TipTap editor.
+
+### List builder
+
+Each list item is a row with:
+- Checkbox (toggle checked state)
+- Text input (item text, fills available width)
+- Delete button (× icon, right side)
+
+Below the items: an "Add item" button.
+
+### Behavior
+
+- **Enter** in any item input: creates a new item below and focuses it
+- **Backspace** on an empty item: deletes the item and focuses the previous one
+- **Checkbox toggle**: updates the item's checked state
+- **Delete button**: removes the item
+
+### Serialization
+
+On save, list items are serialized to markdown checkbox format in the body:
+```markdown
+- [ ] Buy groceries
+- [x] Call dentist
+- [ ] Pick up prescription
+```
+
+On load, the body is parsed back into structured items (same parser already exists in `knowledge.py` and `KnowledgeView.vue`).
+
+### Notes section
+
+Same collapsible TipTap "Notes" section below the list builder, for additional context that isn't a list item.
+
+### Layout
+
+```
+┌──────────────────────────────────────────┐
+│ [← Knowledge]  [Save]  [Delete]          │
+│                                          │
+│ List title: [____________________________│
+│                                          │
+│ [ ] Buy groceries                    [×] │
+│ [x] Call dentist                     [×] │
+│ [ ] Pick up prescription            [×] │
+│                                          │
+│ [+ Add item]                             │
+│                                          │
+│ ▾ Notes                                  │
+│ ┌──────────────────────────────────────┐ │
+│ │ TipTap editor (additional context)  │ │
+│ └──────────────────────────────────────┘ │
+│                                          │
+│           [sidebar: project/tags/etc]    │
+└──────────────────────────────────────────┘
+```
+
+## Tab Navigation & Auto-Focus
+
+### All note types
+
+1. **On page load**: focus the title/name input automatically
+2. **Tab from title**: skip the formatting toolbar entirely, go to the first content field:
+   - Note: TipTap editor body
+   - Person: Relationship field
+   - Place: Address field
+   - List: first list item (or "Add item" button if empty)
+3. **Tab through fields**: natural order through all form fields
+4. **Tab from last form field**: enter the Notes section (TipTap editor)
+
+### Implementation
+
+Set `tabindex="-1"` on all MarkdownToolbar buttons so they are clickable but not in the tab order. The toolbar remains fully functional via mouse/touch — it's just skipped when tabbing.
+
+### Title placeholder by type
+
+| Type | Placeholder |
+|------|-------------|
+| Note | "Title" |
+| Person | "Name" |
+| Place | "Place name" |
+| List | "List title" |
+| Task | "Title" (unchanged, task editor is separate) |
+
+## Sidebar changes
+
+When editing a Person or Place, the type-specific metadata fields (Relationship, Email, Phone, etc.) **move from the sidebar to the main content area**. The sidebar keeps: Project, Milestone, Tags, Suggest Tags, Type selector, Link Suggestions, Writing Assistant, Version History.
+
+The Type selector remains in the sidebar so users can change the type if needed. Changing type switches the layout.
+
+## Backend changes
+
+### New entity metadata fields
+
+The `entity_meta` JSON column on the Note model already stores arbitrary key-value pairs. No schema migration needed — just store the new keys:
+
+- Person: `birthday`, `organization`, `address` (new; `relationship`, `email`, `phone` existing)
+- Place: `website`, `category` (new; `address`, `phone`, `hours` existing)
+
+### Knowledge service
+
+Update `_note_to_item` in `services/knowledge.py` to include the new fields in the response for person and place cards:
+
+- Person: add `birthday`, `organization`, `address`
+- Place: add `website`, `category`
+
+### Knowledge card display
+
+Update `KnowledgeView.vue` card rendering to show the new fields where useful (e.g. organization on person cards, category on place cards).
+
+## Files changed
+
+| File | Change |
+|------|--------|
+| `frontend/src/views/NoteEditorView.vue` | Type-conditional layouts, form fields, list builder, tab navigation, auto-focus, title placeholders |
+| `frontend/src/views/KnowledgeView.vue` | Card display for new person/place fields |
+| `frontend/src/components/MarkdownToolbar.vue` | `tabindex="-1"` on all buttons |
+| `src/fabledassistant/services/knowledge.py` | New fields in `_note_to_item` for person/place |
+
+## What does NOT change
+
+- Note model / database schema (entity_meta is already a JSON column)
+- API endpoints (same CRUD)
+- Task editor (`TaskEditorView.vue`) — separate component, unchanged
+- Generic note editing — TipTap-first layout stays for `noteType === 'note'`
+- Backend storage format — entity_meta key-value pairs

docs/superpowers/specs/2026-04-17-unified-lookup-wikipedia-design.md

@@ -0,0 +1,119 @@
+# Unified Lookup Tool & Wikipedia Integration
+
+## Goal
+
+Replace the fragmented `search_web` tool with a single `lookup` tool that checks Wikipedia first and falls back to SearXNG web search. Add Wikipedia as an additional source in the research pipeline. Result: one lightweight tool for factual questions (always available, no config required), and richer research output.
+
+## Architecture
+
+Two changes to the search/knowledge stack:
+
+1. **New `lookup` tool** replaces `search_web`. Tries Wikipedia REST API summary endpoint first (~200ms, reliable, no config). Falls back to SearXNG + trafilatura article fetch when Wikipedia misses and SearXNG is configured. Always available (no `requires` field).
+
+2. **Wikipedia sources in research pipeline.** During sub-query execution, `wiki_search` runs alongside `_search_searxng`. Wikipedia articles merge into the source pool and get deduplicated by URL.
+
+Shared Wikipedia logic lives in a new `wikipedia.py` service module.
+
+## Components
+
+### `src/fabledassistant/services/wikipedia.py` (new)
+
+Two async functions:
+
+**`wiki_summary(query: str) -> dict | None`**
+- Direct title lookup via `https://en.wikipedia.org/api/rest_v1/page/summary/{title}`
+- Returns `{"title": str, "extract": str, "url": str}` on hit
+- Returns `None` on 404, disambiguation pages (`"type": "disambiguation"`), network errors, or empty extracts
+- 5-second timeout
+- User-Agent: `"FabledAssistant/1.0 (https://fabledsword.com)"`
+
+**`wiki_search(query: str, limit: int = 3) -> list[dict]`**
+- Search via `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={query}&srlimit={limit}&format=json`
+- For each search result, fetch its summary via the summary endpoint to get the extract
+- Returns `[{"title": str, "extract": str, "url": str}, ...]`
+- Returns `[]` on any failure
+- Same timeout and User-Agent as above
+
+### `src/fabledassistant/services/tools/web.py` (modified)
+
+**Remove:** `search_web_tool`
+
+**Add:** `lookup_tool`
+
+```
+@tool(
+    name="lookup",
+    description="Look up a topic, concept, or factual question. Returns a concise
+                 answer from Wikipedia or web sources. Use for definitions,
+                 explanations, 'what is X', 'how does Y work'. For comprehensive
+                 written reports saved as notes, use research_topic instead.",
+    parameters={
+        "query": {"type": "string", "description": "The topic or question to look up"},
+    },
+    required=["query"],
+)
+```
+
+No `requires` field — always available.
+
+**Logic:**
+1. Call `wiki_summary(query)`
+2. If Wikipedia returns a result: return `{"success": True, "type": "lookup", "source": "wikipedia", "data": {"title": ..., "extract": ..., "url": ...}}`
+3. If Wikipedia misses and `Config.searxng_enabled()`:
+   - Call `_search_searxng(query)` to get search results
+   - Fetch top 1-2 result URLs via `_fetch_full_article` (from `rss.py`, trafilatura-based)
+   - Return `{"success": True, "type": "lookup", "source": "web", "data": {"query": ..., "results": [...], "content": ...}}`
+4. If Wikipedia misses and no SearXNG: return `{"success": True, "type": "lookup", "source": "none", "data": {"query": ..., "message": "No results found. You can answer from your own knowledge."}}`
+
+### `src/fabledassistant/services/research.py` (modified)
+
+**In Step 2 (parallel search):**
+- For each sub-query, run `wiki_search(query, limit=1)` concurrently with `_search_searxng(query)`
+- Merge Wikipedia results into the per-query result list
+
+**In Step 3 (deduplication):**
+- When deduplicating URLs, Wikipedia URLs (`wikipedia.org`) are checked against SearXNG results
+- If a Wikipedia article URL already appears in SearXNG results, skip the duplicate
+
+**Wikipedia article content for synthesis:**
+- The `extract` from `wiki_search` is used as the source content (no additional fetch needed, unlike SearXNG URLs which require `fetch_url_content`)
+- This means Wikipedia sources are available immediately without an HTTP fetch step
+
+## Error Handling
+
+- All Wikipedia API failures (network, timeout, malformed JSON) return `None`/`[]` silently
+- `lookup` never raises — always returns a response the model can work with
+- In the research pipeline, Wikipedia is purely additive; its failure never degrades existing SearXNG-based research
+- Disambiguation pages are detected via `"type": "disambiguation"` in the summary response and treated as a miss
+
+## Testing
+
+### `tests/test_wikipedia.py` (new)
+
+- `test_wiki_summary_returns_extract` — mock successful summary response, verify return shape
+- `test_wiki_summary_returns_none_on_404` — mock 404, verify `None`
+- `test_wiki_summary_returns_none_on_disambiguation` — mock disambiguation response, verify `None`
+- `test_wiki_search_returns_results` — mock search API + summary fetches, verify list
+- `test_wiki_search_returns_empty_on_failure` — mock network error, verify `[]`
+
+### `tests/test_lookup_tool.py` (new)
+
+- `test_lookup_wikipedia_hit` — mock `wiki_summary` returning data, verify tool returns wikipedia source
+- `test_lookup_wikipedia_miss_searxng_fallback` — mock `wiki_summary` returning None, SearXNG returning results + article fetch, verify web source
+- `test_lookup_wikipedia_miss_no_searxng` — mock both missing, verify graceful "no results" response
+- `test_lookup_always_available` — verify the tool appears in `get_tools_for_user` regardless of SearXNG config
+
+### `tests/test_research_pipeline.py` (add to existing)
+
+- `test_research_includes_wikipedia_sources` — mock `wiki_search` alongside SearXNG, verify Wikipedia results appear in source pool
+
+All tests mock HTTP calls — no live API hits.
+
+## What Doesn't Change
+
+- `read_article` tool — stays as-is (explicit URL fetch, different purpose)
+- `research_topic` tool definition — stays as-is (same name, description, parameters)
+- `generation_task.py` research interception — stays as-is
+- `search_images` tool — stays as-is
+- `_search_searxng` and `_search_searxng_images` — stay as-is
+- `_fetch_full_article` in `rss.py` — stays as-is, reused by `lookup` for SearXNG fallback

fable-mcp/fable_mcp/server.py

@@ -27,7 +27,7 @@ The hierarchy is: Project → Milestone → Task/Note.
 
 - **Tasks** belong to a project and optionally a milestone. They support sub-tasks via `parent_id`.
   - Status values: `todo`, `in_progress`, `done`, `cancelled`
-  - Priority values: `low`, `normal`, `high`
+  - Priority values: `none` (default), `low`, `medium`, `high`
 
 - **Notes** are free-form markdown documents. They can belong to a project or be standalone
   (orphan notes). Orphan notes are included in the default RAG scope for chat conversations.
@@ -241,7 +241,7 @@ async def fable_create_task(
         title: Task title (required).
         body: Markdown description / notes for the task.
         status: Initial status — one of: todo (default), in_progress, done, cancelled.
-        priority: One of: low, normal, high. Omit for no priority.
+        priority: One of: low, medium, high. Omit for no priority (defaults to "none").
         project_id: Associate with a project (0 = no project).
         milestone_id: Place within a project milestone (0 = no milestone).
         parent_id: Make this a sub-task of another task (0 = top-level).
@@ -280,7 +280,7 @@ async def fable_update_task(
         title: New title, or omit to leave unchanged.
         body: New markdown body, or omit to leave unchanged.
         status: New status — one of: todo, in_progress, done, cancelled.
-        priority: New priority — one of: low, normal, high.
+        priority: New priority — one of: none, low, medium, high.
         project_id: New project (0 = remove from project). Omit to leave unchanged.
         milestone_id: New milestone (0 = remove from milestone). Omit to leave unchanged.
     """
@@ -628,6 +628,128 @@ async def fable_remove_rss_feed(feed_id: int) -> dict:
         return await briefing.remove_rss_feed(client, feed_id=feed_id)
 
 
+# ---------------------------------------------------------------------------
+# Briefing introspection & control
+# ---------------------------------------------------------------------------
+
+
+@mcp.tool()
+async def fable_list_briefings() -> dict:
+    """List the user's briefing conversations, newest first.
+
+    Each briefing has an associated date and conversation id. Use
+    ``fable_get_briefing_messages`` or ``fable_get_conversation`` with
+    the id to pull the actual briefing text and tool-call receipts.
+
+    Returns a dict with a ``conversations`` list.
+    """
+    async with FableClient() as client:
+        return await briefing.list_briefing_conversations(client)
+
+
+@mcp.tool()
+async def fable_get_today_briefing() -> dict:
+    """Fetch today's briefing conversation, creating it if needed.
+
+    Returns the full conversation object including all messages — the
+    scheduled briefing assistant turns, any tool calls the agentic path
+    made, and any chat replies the user has sent in the briefing thread.
+
+    Use this to inspect what a briefing actually said (and what tool
+    results grounded it) without having to query by id.
+    """
+    async with FableClient() as client:
+        return await briefing.get_today_briefing(client)
+
+
+@mcp.tool()
+async def fable_get_briefing_messages(conversation_id: int) -> dict:
+    """Fetch all messages for a specific briefing conversation.
+
+    Args:
+        conversation_id: The briefing conversation id from fable_list_briefings.
+
+    Returns a dict with a ``messages`` list. Each message includes
+    role, content, tool_calls (with results), and metadata — the
+    metadata carries ``briefing_slot`` tags on agentic briefing turns.
+    """
+    async with FableClient() as client:
+        return await briefing.get_briefing_messages(
+            client, conversation_id=conversation_id,
+        )
+
+
+@mcp.tool()
+async def fable_trigger_briefing(slot: str = "compilation") -> dict:
+    """Manually run a briefing slot for the current user.
+
+    Fires the same data refresh the scheduler does (RSS, weather),
+    runs the agentic briefing pipeline, and writes the result into
+    today's briefing conversation. Use this to test prompt changes
+    without waiting for the next scheduled slot.
+
+    Args:
+        slot: One of ``compilation`` (full morning, default), ``morning``,
+              ``midday``, or ``afternoon``.
+
+    Returns a dict with ``conversation_id``, ``message_id``, and ``slot``.
+    """
+    async with FableClient() as client:
+        return await briefing.trigger_briefing(client, slot=slot)
+
+
+@mcp.tool()
+async def fable_reset_today_briefing(run_compilation: bool = True) -> dict:
+    """Wipe today's briefing and (optionally) regenerate from scratch.
+
+    Deletes every message in today's briefing conversation — the
+    conversation row itself is kept so its id stays stable for any
+    open UI sessions. If ``run_compilation`` is True (the default),
+    immediately fires the compilation slot afterward so a fresh
+    briefing lands in place of the deleted content.
+
+    Use this when iterating on briefing prompts or tools and you want
+    to start from a clean slate rather than append another slot update
+    on top of stale output.
+
+    Args:
+        run_compilation: When True, fire ``POST /api/briefing/trigger``
+            for the ``compilation`` slot immediately after wiping.
+            Set False to only wipe without regenerating.
+
+    Returns a dict with ``reset`` (the delete result: deleted count +
+    conversation id) and ``triggered`` (the new message payload, or
+    null if regeneration was skipped).
+    """
+    async with FableClient() as client:
+        return await briefing.reset_today_briefing(
+            client, run_compilation=run_compilation,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Generic conversation access
+# ---------------------------------------------------------------------------
+
+
+@mcp.tool()
+async def fable_get_conversation(conversation_id: int) -> dict:
+    """Fetch any conversation (chat or briefing) with its full message list.
+
+    Returns conversation metadata plus an ordered ``messages`` array.
+    Each message includes role, content, tool_calls (with results),
+    context_note_id, and msg_metadata. Tool calls are in the stored
+    flat format: ``[{"function": name, "arguments": {...}, "result": {...}}]``.
+
+    Useful for debugging agentic briefings, inspecting chat history,
+    or verifying that a tool actually ran with the expected arguments.
+    """
+    async with FableClient() as client:
+        return await briefing.get_conversation(
+            client, conversation_id=conversation_id,
+        )
+
+
 # ---------------------------------------------------------------------------
 # Entry point
 # ---------------------------------------------------------------------------

fable-mcp/fable_mcp/tools/briefing.py

@@ -1,4 +1,4 @@
-"""MCP tools for Fable RSS feed management."""
+"""MCP tools for Fable briefings and RSS feed management."""
 from __future__ import annotations
 
 from typing import Any
@@ -6,6 +6,8 @@ from typing import Any
 from fable_mcp.client import FableClient
 
 
+# ── RSS feeds ────────────────────────────────────────────────────────────────
+
 async def list_rss_feeds(client: FableClient) -> dict[str, Any]:
     """List the user's RSS feeds."""
     return await client.get("/api/briefing/feeds")
@@ -30,3 +32,67 @@ async def add_rss_feed(
 async def remove_rss_feed(client: FableClient, *, feed_id: int) -> dict[str, Any]:
     """Remove an RSS feed by ID."""
     return await client.delete(f"/api/briefing/feeds/{feed_id}")
+
+
+# ── Briefings ────────────────────────────────────────────────────────────────
+
+async def list_briefing_conversations(client: FableClient) -> dict[str, Any]:
+    """List the user's briefing conversations, newest first."""
+    return await client.get("/api/briefing/conversations")
+
+
+async def get_today_briefing(client: FableClient) -> dict[str, Any]:
+    """Fetch today's briefing conversation with all messages."""
+    return await client.get("/api/briefing/conversations/today")
+
+
+async def get_briefing_messages(
+    client: FableClient,
+    *,
+    conversation_id: int,
+) -> dict[str, Any]:
+    """Fetch messages for a specific briefing conversation."""
+    return await client.get(f"/api/briefing/conversations/{conversation_id}/messages")
+
+
+async def trigger_briefing(
+    client: FableClient,
+    *,
+    slot: str = "compilation",
+) -> dict[str, Any]:
+    """Manually trigger a briefing slot — fires data refresh and runs the pipeline.
+
+    Slot is one of: compilation (full morning), morning, midday, afternoon.
+    """
+    return await client.post("/api/briefing/trigger", json={"slot": slot})
+
+
+async def reset_today_briefing(
+    client: FableClient,
+    *,
+    run_compilation: bool = True,
+) -> dict[str, Any]:
+    """Delete all messages in today's briefing and optionally regenerate.
+
+    Wipes the messages in today's briefing conversation (keeping the
+    conversation row), then, if ``run_compilation`` is True, fires the
+    compilation slot so a fresh briefing lands in its place.
+    """
+    reset = await client.post("/api/briefing/reset-today")
+    if not run_compilation:
+        return {"reset": reset, "triggered": None}
+    triggered = await client.post(
+        "/api/briefing/trigger", json={"slot": "compilation"}
+    )
+    return {"reset": reset, "triggered": triggered}
+
+
+# ── Generic conversations ───────────────────────────────────────────────────
+
+async def get_conversation(
+    client: FableClient,
+    *,
+    conversation_id: int,
+) -> dict[str, Any]:
+    """Fetch any conversation (chat or briefing) with all messages and tool calls."""
+    return await client.get(f"/api/chat/conversations/{conversation_id}")

fable-mcp/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fable-mcp"
-version = "0.2.4"
+version = "0.2.6"
 description = "MCP server for Fabled Assistant"
 requires-python = ">=3.12"
 dependencies = [

frontend/package.json

@@ -14,6 +14,7 @@
     "@fullcalendar/interaction": "^6.1.20",
     "@fullcalendar/timegrid": "^6.1.20",
     "@fullcalendar/vue3": "^6.1.20",
+    "@ricky0123/vad-web": "^0.0.30",
     "@tiptap/core": "^3.0.0",
     "@tiptap/extension-link": "^3.0.0",
     "@tiptap/extension-list": "^3.0.0",
@@ -35,6 +36,7 @@
     "@vitejs/plugin-vue": "^6.0.0",
     "typescript": "~5.9.0",
     "vite": "^7.0.0",
+    "vite-plugin-static-copy": "^4.0.1",
     "vue-tsc": "^3.0.0"
   }
 }

frontend/src/App.vue

@@ -5,6 +5,7 @@ import AppHeader from "@/components/AppHeader.vue";
 import ToastNotification from "@/components/ToastNotification.vue";
 import { useTheme } from "@/composables/useTheme";
 import { useShortcuts } from "@/composables/useShortcuts";
+import { useOnnxPreloader } from "@/composables/useOnnxPreloader";
 import { useAuthStore } from "@/stores/auth";
 import { useChatStore } from "@/stores/chat";
 import { useSettingsStore } from "@/stores/settings";
@@ -12,6 +13,9 @@ import { apiGet, apiPut } from "@/api/client";
 
 useTheme();
 
+const { schedulePreload: scheduleVadPreload } = useOnnxPreloader();
+scheduleVadPreload();
+
 const router = useRouter();
 const appVersion = ref("dev");
 const authStore = useAuthStore();

frontend/src/api/client.ts

@@ -426,7 +426,9 @@ export async function deleteRssReaction(rssItemId: number): Promise<void> {
   return apiDelete(`/api/briefing/rss-reactions/${rssItemId}`);
 }
 
-export async function openArticleInChat(itemId: number): Promise<{ conversation_id: number }> {
+export async function openArticleInChat(
+  itemId: number,
+): Promise<{ conversation_id: number; assistant_message_id?: number; status?: string }> {
   return apiPost(`/api/chat/from-article/${itemId}`, {});
 }
 

frontend/src/assets/theme.css

@@ -54,10 +54,20 @@
   --page-max-width: 1200px;
   --page-padding-x: 1rem;
   --sidebar-width: 260px;
+  --chat-reading-width: min(1200px, 100%);
+  --chat-context-sidebar-width: 220px;
   --color-accent-warm: #b8860b;
   --color-accent-warm-light: #d4a017;
   --color-primary-solid: #7c3aed;
   --color-primary-deep: #5b21b6;
+  /* Reusable brand patterns */
+  --gradient-cta: linear-gradient(135deg, var(--color-primary-solid), var(--color-primary-deep));
+  --glow-cta: 0 2px 10px rgba(124, 58, 237, 0.35);
+  --glow-cta-hover: 0 4px 20px rgba(124, 58, 237, 0.55);
+  --glow-soft: 0 0 16px rgba(124, 58, 237, 0.35);
+  --color-primary-faint: rgba(124, 58, 237, 0.08);
+  --color-primary-tint: rgba(124, 58, 237, 0.12);
+  --color-primary-wash: rgba(124, 58, 237, 0.20);
 }
 
 [data-theme="dark"] {
@@ -68,8 +78,8 @@
   --color-text: #e4e4f0;
   --color-text-secondary: #8888a8;
   --color-text-muted: #52526a;
-  --color-border: rgba(124, 58, 237, 0.12);
-  --color-input-border: rgba(124, 58, 237, 0.22);
+  --color-border: rgba(124, 58, 237, 0.22);
+  --color-input-border: rgba(124, 58, 237, 0.35);
   --color-primary: #a78bfa;
   --color-danger: #f44336;
   --color-tag-bg: #2a2a45;
@@ -109,6 +119,13 @@
   --color-accent-warm-light: #e8c45a;
   --color-primary-solid: #7c3aed;
   --color-primary-deep: #5b21b6;
+  --gradient-cta: linear-gradient(135deg, var(--color-primary-solid), var(--color-primary-deep));
+  --glow-cta: 0 2px 12px rgba(124, 58, 237, 0.45);
+  --glow-cta-hover: 0 4px 24px rgba(124, 58, 237, 0.65);
+  --glow-soft: 0 0 18px rgba(124, 58, 237, 0.4);
+  --color-primary-faint: rgba(124, 58, 237, 0.10);
+  --color-primary-tint: rgba(124, 58, 237, 0.14);
+  --color-primary-wash: rgba(124, 58, 237, 0.22);
 }
 
 *,

frontend/src/components/AppHeader.vue

@@ -5,6 +5,7 @@ import { useTheme } from "@/composables/useTheme";
 import { useShortcuts } from "@/composables/useShortcuts";
 import { useAuthStore } from "@/stores/auth";
 import { useChatStore } from "@/stores/chat";
+import { useSettingsStore } from "@/stores/settings";
 import AppLogo from "@/components/AppLogo.vue";
 import NotificationBell from "@/components/NotificationBell.vue";
 
@@ -12,6 +13,7 @@ const { theme, toggleTheme } = useTheme();
 const { toggleShortcuts } = useShortcuts();
 const authStore = useAuthStore();
 const chatStore = useChatStore();
+const settingsStore = useSettingsStore();
 const router = useRouter();
 const route = useRoute();
 
@@ -78,7 +80,7 @@ router.afterEach(() => {
           <router-link to="/chat" :class="['nav-link', { 'router-link-active': isChatActive }]">Chat</router-link>
           <router-link to="/briefing" class="nav-link">Briefing</router-link>
           <router-link to="/calendar" class="nav-link">Calendar</router-link>
-          <router-link to="/news" class="nav-link">News</router-link>
+          <router-link v-if="settingsStore.rssEnabled" to="/news" class="nav-link">News</router-link>
           <router-link to="/projects" class="nav-link">Projects</router-link>
         </div>
       </div>
@@ -128,7 +130,7 @@ router.afterEach(() => {
       <router-link to="/briefing" class="nav-link">Briefing</router-link>
       <router-link to="/calendar" class="nav-link">Calendar</router-link>
       <router-link to="/projects" class="nav-link">Projects</router-link>
-      <router-link to="/news" class="nav-link">News</router-link>
+      <router-link v-if="settingsStore.rssEnabled" to="/news" class="nav-link">News</router-link>
       <router-link to="/shared" class="nav-link">Shared</router-link>
       <div class="mobile-divider"></div>
       <router-link to="/settings" class="nav-link">Settings</router-link>
@@ -153,7 +155,7 @@ router.afterEach(() => {
 <style scoped>
 .app-header {
   background: linear-gradient(180deg, var(--color-surface), var(--color-bg));
-  border-bottom: 1px solid rgba(124, 58, 237, 0.08);
+  border-bottom: 1px solid rgba(124, 58, 237, 0.18);
   position: relative;
 }
 .nav {
@@ -194,7 +196,7 @@ router.afterEach(() => {
   display: flex;
   align-items: center;
   gap: 2px;
-  background: rgba(124, 58, 237, 0.06);
+  background: var(--color-primary-faint);
   border-radius: 10px;
   padding: 3px;
 }
@@ -208,7 +210,7 @@ router.afterEach(() => {
 }
 
 .nav-link {
-  color: var(--color-text-muted);
+  color: var(--color-text-secondary);
   text-decoration: none;
   font-size: 0.82rem;
   padding: 0.3rem 0.75rem;
@@ -216,14 +218,14 @@ router.afterEach(() => {
   transition: background 0.15s, color 0.15s;
 }
 .nav-link:hover {
-  color: var(--color-text-secondary);
-  background: rgba(124, 58, 237, 0.08);
+  color: var(--color-text);
+  background: var(--color-primary-tint);
 }
 .nav-link.router-link-active {
-  color: #c4b5fd;
+  color: var(--color-primary-solid);
   font-weight: 600;
-  background: rgba(124, 58, 237, 0.2);
-  box-shadow: 0 0 12px rgba(124, 58, 237, 0.2);
+  background: rgba(124, 58, 237, 0.25);
+  box-shadow: 0 0 16px rgba(124, 58, 237, 0.3);
 }
 
 /* Status indicator */
@@ -387,7 +389,7 @@ router.afterEach(() => {
     border-radius: 8px;
   }
   .mobile-menu .nav-link.router-link-active {
-    background: rgba(124, 58, 237, 0.15);
+    background: var(--color-primary-wash);
     box-shadow: none;
   }
   .mobile-user .btn-logout {

frontend/src/components/BriefingSetupWizard.vue

@@ -247,7 +247,7 @@ async function finish() {
 }
 .wizard-progress-fill {
   height: 100%;
-  background: linear-gradient(90deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   transition: width 0.3s ease;
 }
 .wizard-step-label {
@@ -375,7 +375,7 @@ async function finish() {
 }
 .btn-wizard-primary {
   padding: 0.5rem 1.25rem;
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: 8px;

frontend/src/components/BriefingToolStatusRow.vue

@@ -0,0 +1,168 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import ToolCallCard from "@/components/ToolCallCard.vue";
+import type { ToolCallRecord } from "@/types/chat";
+
+const props = defineProps<{
+  toolCalls: ToolCallRecord[];
+}>();
+
+const expanded = ref(false);
+
+function shortName(fn: string): string {
+  return fn
+    .replace(/^(list|get|search|fetch)_/, "")
+    .replace(/_/g, " ");
+}
+
+interface Pill {
+  key: string;
+  name: string;
+  count: string | null;
+  state: "ok" | "empty" | "error";
+}
+
+const pills = computed<Pill[]>(() =>
+  props.toolCalls.map((tc, i) => {
+    const ok = tc.result?.success !== false && tc.status !== "error";
+    const data = tc.result?.data as Record<string, unknown> | undefined;
+    let count: string | null = null;
+    let state: Pill["state"] = ok ? "ok" : "error";
+    if (ok && data) {
+      const raw =
+        (typeof data.count === "number" && data.count) ||
+        (typeof data.total === "number" && data.total);
+      if (typeof raw === "number") {
+        count = String(raw);
+        if (raw === 0) state = "empty";
+      }
+    }
+    return {
+      key: `${tc.function}-${i}`,
+      name: shortName(tc.function),
+      count,
+      state,
+    };
+  }),
+);
+
+const errorCount = computed(() => pills.value.filter((p) => p.state === "error").length);
+</script>
+
+<template>
+  <div class="briefing-status" :class="{ expanded }">
+    <button class="briefing-status-toggle" @click="expanded = !expanded">
+      <span class="briefing-status-label">Gathered</span>
+      <span
+        v-for="p in pills"
+        :key="p.key"
+        class="briefing-status-pill"
+        :class="`state-${p.state}`"
+      >
+        {{ p.name }}<span v-if="p.count != null" class="pill-count">{{ p.count }}</span>
+      </span>
+      <span v-if="errorCount" class="briefing-status-errcount">{{ errorCount }} failed</span>
+      <span class="briefing-status-chevron" :class="{ open: expanded }">▶</span>
+    </button>
+    <div v-if="expanded" class="briefing-status-detail">
+      <ToolCallCard
+        v-for="(tc, i) in toolCalls"
+        :key="i"
+        :tool-call="tc"
+      />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.briefing-status {
+  margin: 0.25rem 0 0.5rem;
+  max-width: 80%;
+}
+
+.briefing-status-toggle {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.35rem;
+  width: 100%;
+  padding: 0.35rem 0.55rem;
+  background: transparent;
+  border: 1px dashed var(--color-border);
+  border-radius: 8px;
+  cursor: pointer;
+  font: inherit;
+  color: var(--color-text-muted);
+  transition: border-color 0.15s, background 0.15s;
+}
+.briefing-status-toggle:hover {
+  border-color: var(--color-primary);
+  background: color-mix(in srgb, var(--color-primary) 4%, transparent);
+}
+
+.briefing-status-label {
+  font-family: 'Fraunces', Georgia, serif;
+  font-style: italic;
+  font-size: 0.78rem;
+  color: var(--color-primary);
+  opacity: 0.85;
+  margin-right: 0.15rem;
+}
+
+.briefing-status-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.08rem 0.45rem;
+  font-size: 0.72rem;
+  line-height: 1.45;
+  border-radius: 999px;
+  border: 1px solid var(--color-border);
+  color: var(--color-text-secondary);
+  background: var(--color-bg-card);
+  white-space: nowrap;
+}
+.briefing-status-pill.state-empty {
+  opacity: 0.55;
+}
+.briefing-status-pill.state-error {
+  border-color: color-mix(in srgb, var(--color-danger, #ef4444) 60%, var(--color-border));
+  color: var(--color-danger, #ef4444);
+}
+
+.pill-count {
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  padding: 0 0.25rem;
+  border-radius: 4px;
+  background: color-mix(in srgb, var(--color-primary) 12%, transparent);
+  color: var(--color-text);
+}
+.state-error .pill-count {
+  background: color-mix(in srgb, var(--color-danger, #ef4444) 18%, transparent);
+}
+
+.briefing-status-errcount {
+  font-size: 0.7rem;
+  color: var(--color-danger, #ef4444);
+  font-weight: 600;
+}
+
+.briefing-status-chevron {
+  margin-left: auto;
+  font-size: 0.65rem;
+  opacity: 0.5;
+  transition: transform 0.15s;
+}
+.briefing-status-chevron.open {
+  transform: rotate(90deg);
+}
+
+.briefing-status-detail {
+  margin-top: 0.4rem;
+  padding-left: 0.55rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.3rem;
+}
+</style>

frontend/src/components/ChatInputBar.vue

@@ -1,8 +1,11 @@
 <script setup lang="ts">
-import { ref, computed, nextTick } from 'vue'
+import { ref, computed, nextTick, onMounted, onUnmounted, watch } from 'vue'
 import { apiGet, transcribeAudio } from '@/api/client'
 import { useVoiceRecorder } from '@/composables/useVoiceRecorder'
-import { useSilenceDetector } from '@/composables/useSilenceDetector'
+import { useVad } from '@/composables/useVad'
+import { useStreamingTts } from '@/composables/useStreamingTts'
+import { useVoiceAudio, setVoiceVolume } from '@/composables/useVoiceAudio'
+import { useListenMode } from '@/composables/useListenMode'
 import { useChatStore } from '@/stores/chat'
 import { useSettingsStore } from '@/stores/settings'
 import { useToastStore } from '@/stores/toast'
@@ -29,6 +32,32 @@ const emit = defineEmits<{
 const store = useChatStore()
 const settingsStore = useSettingsStore()
 const voiceEnabled = computed(() => settingsStore.voiceSttReady)
+const voiceTtsEnabled = computed(() => settingsStore.voiceTtsReady)
+
+// ── Streaming TTS (listen mode) ───────────────────────────────────────────────
+const listenMode = useListenMode()
+const audio = useVoiceAudio()
+const speakerPopoverOpen = ref(false)
+
+const tts = useStreamingTts({
+  streamingContent: computed(() => store.streamingContent),
+  streaming: computed(() => store.streaming),
+  enabled: computed(() => listenMode.value && voiceTtsEnabled.value),
+})
+
+function lastAssistantContent(): string {
+  const msgs = store.currentConversation?.messages ?? []
+  return [...msgs].reverse().find((m) => m.role === 'assistant')?.content ?? ''
+}
+
+function toggleListen() {
+  listenMode.value = !listenMode.value
+  if (listenMode.value) {
+    tts.speak(lastAssistantContent())
+  } else {
+    tts.stop()
+  }
+}
 
 // ── Core input ────────────────────────────────────────────────────────────────
 const messageInput = ref('')
@@ -109,15 +138,50 @@ function removeAttachedNote() {
   attachedNote.value = null
 }
 
-// ── Voice (click-to-toggle + silence detection) ─────────────────────────────
+// ── Voice (click-to-toggle + VAD speech detection) ─────────────────────────
 const transcribingVoice = ref(false)
 const recorder = useVoiceRecorder()
-const silenceDetector = useSilenceDetector()
+// Tracks whether VAD detected speech during the current recording session.
+// Used to skip the Whisper round-trip when the user manually stops without
+// ever speaking — the recording is ambient noise and will transcribe to "".
+const vadSawSpeech = ref(false)
+
+const vad = useVad({
+  onSpeechEnd: () => {
+    // VAD auto-stop: speech was detected and the user has paused. Proceed
+    // to transcribe the MediaRecorder output.
+    void stopRecording(false)
+  },
+  onNoSpeech: () => {
+    useToastStore().show('No speech detected', 'warning')
+  },
+  onVadError: (msg) => {
+    useToastStore().show(`VAD failed: ${msg}`, 'error')
+  },
+})
+
+// Live mic halo. A solid red disc sits behind the mic button and scales
+// with `vad.amplitude` (0..1 RMS, already amplified for visibility).
+const micGlowStyle = computed(() => {
+  if (!recorder.recording.value) return { display: 'none' }
+  const pulse = 0.2 + Math.min(vad.amplitude.value, 1) * 0.8
+  return {
+    transform: `translate(-50%, -50%) scale(${1 + pulse * 1.6})`,
+    opacity: String(0.45 + pulse * 0.4),
+  }
+})
+
+// vad.speaking flips true on speech-start. Watch it once per session to
+// capture that speech was detected at some point, without clearing when
+// speech ends. This drives the no-speech guard in stopRecording.
+watch(() => vad.speaking.value, (on) => {
+  if (on) vadSawSpeech.value = true
+})
 
 async function toggleVoice() {
   if (transcribingVoice.value) return
   if (recorder.recording.value) {
-    await stopRecording()
+    await stopRecording(true)
   } else {
     await startRecording()
   }
@@ -129,22 +193,32 @@ async function startRecording() {
     useToastStore().show('Microphone requires HTTPS or localhost', 'error')
     return
   }
+  vadSawSpeech.value = false
   await recorder.startRecording()
   if (recorder.error.value) {
     useToastStore().show(recorder.error.value, 'error')
     return
   }
   if (recorder.stream.value) {
-    silenceDetector.start(recorder.stream.value, () => stopRecording())
+    await vad.start(recorder.stream.value)
   }
 }
 
-async function stopRecording() {
-  silenceDetector.stop()
+async function stopRecording(manual: boolean) {
+  if (manual) {
+    await vad.stopAndCheck()
+  } else {
+    await vad.stop()
+  }
   if (!recorder.recording.value) return
   transcribingVoice.value = true
   try {
     const blob = await recorder.stopRecording()
+    // No-speech guard: user manually stopped without VAD seeing speech.
+    // Skip Whisper — the toast was already shown by onNoSpeech.
+    if (manual && !vadSawSpeech.value) {
+      return
+    }
     // Pass last assistant message as context to reduce STT mishearings
     const msgs = store.currentConversation?.messages ?? []
     const lastAssistant = [...msgs].reverse().find(m => m.role === 'assistant')?.content
@@ -159,6 +233,15 @@ async function stopRecording() {
   finally { transcribingVoice.value = false }
 }
 
+// ── Click-outside to dismiss speaker popover ──────────────────────────────────
+function onDocumentMousedown(e: MouseEvent) {
+  if (!speakerPopoverOpen.value) return
+  const target = e.target as HTMLElement | null
+  if (!target?.closest('.speaker-wrapper')) speakerPopoverOpen.value = false
+}
+onMounted(() => document.addEventListener('mousedown', onDocumentMousedown))
+onUnmounted(() => document.removeEventListener('mousedown', onDocumentMousedown))
+
 // ── Exposed interface ─────────────────────────────────────────────────────────
 function focus() {
   inputEl.value?.focus()
@@ -230,23 +313,72 @@ defineExpose({ focus, prefill })
         class="input-textarea"
       ></textarea>
 
-      <!-- PTT mic -->
-      <button
-        v-if="voiceEnabled"
-        class="btn-icon btn-mic"
-        :class="{ 'mic-recording': recorder.recording.value, 'mic-transcribing': transcribingVoice }"
-        @click.prevent="toggleVoice"
-        :disabled="transcribingVoice || !store.chatReady"
-        :title="recorder.recording.value ? 'Click to stop (or wait for silence)' : 'Click to speak'"
-        :aria-label="recorder.recording.value ? 'Stop recording' : 'Start recording'"
-      >
+      <!-- Speaker / listen-mode popover -->
+      <div v-if="voiceTtsEnabled" class="speaker-wrapper">
+        <button
+          class="btn-icon btn-speaker"
+          :class="{ 'speaker-active': listenMode, 'speaker-busy': tts.speaking.value }"
+          @click="speakerPopoverOpen = !speakerPopoverOpen"
+          :title="listenMode ? 'Listen mode on' : 'Listen / volume'"
+          aria-label="Listen and volume settings"
+        >
+          <svg v-if="!tts.speaking.value" width="17" height="17" viewBox="0 0 24 24" fill="currentColor">
+            <path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z"/>
+          </svg>
+          <svg v-else width="17" height="17" viewBox="0 0 24 24" fill="currentColor">
+            <path d="M18 12c0-1.77-1.02-3.29-2.5-4.03v2.21l2.45 2.45c.03-.2.05-.41.05-.63zm2.5 0c0 .94-.2 1.82-.54 2.64l1.51 1.51C21.8 14.82 22 13.43 22 12c0-4.28-2.99-7.86-7-8.77v2.06c2.89.86 5 3.54 5 6.71zM4.27 3L3 4.27 7.73 9H3v6h4l5 5v-6.73l4.25 4.25c-.67.52-1.42.93-2.25 1.18v2.06c1.38-.31 2.63-.95 3.69-1.81L19.73 21 21 19.73l-9-9L4.27 3zM12 4L9.91 6.09 12 8.18V4z"/>
+          </svg>
+        </button>
+        <div v-if="speakerPopoverOpen" class="speaker-popover">
+          <button
+            class="speaker-row speaker-row--toggle"
+            :class="{ 'speaker-row--active': listenMode }"
+            @click="toggleListen"
+          >
+            <span class="speaker-row-label">{{ listenMode ? 'Listening' : 'Read aloud' }}</span>
+            <span class="speaker-switch" :class="{ on: listenMode }"></span>
+          </button>
+          <div class="speaker-row">
+            <span class="speaker-row-label">Volume</span>
+            <input
+              type="range" min="0" max="1" step="0.05"
+              :value="audio.volume.value"
+              @input="setVoiceVolume(+($event.target as HTMLInputElement).value)"
+              class="speaker-volume-range"
+              aria-label="Volume"
+            />
+            <span class="speaker-volume-pct">{{ Math.round(audio.volume.value * 100) }}%</span>
+          </div>
+          <button
+            v-if="tts.speaking.value"
+            class="speaker-row speaker-row--stop"
+            @click="tts.stop()"
+          >
+            <svg width="12" height="12" viewBox="0 0 14 14" fill="currentColor"><rect width="14" height="14" rx="2"/></svg>
+            <span>Stop playback</span>
+          </button>
+        </div>
+      </div>
+
+      <!-- PTT mic (with live amplitude halo behind) -->
+      <div v-if="voiceEnabled" class="mic-wrapper">
+        <div class="mic-glow" :style="micGlowStyle" aria-hidden="true"></div>
+        <button
+          class="btn-icon btn-mic"
+          :class="{ 'mic-recording': recorder.recording.value, 'mic-transcribing': transcribingVoice }"
+          @click.prevent="toggleVoice"
+          :disabled="transcribingVoice || !store.chatReady"
+          :title="recorder.recording.value ? 'Click to stop (or wait for silence)' : 'Click to speak'"
+          :aria-label="recorder.recording.value ? 'Stop recording' : 'Start recording'"
+        >
         <svg v-if="!transcribingVoice" width="17" height="17" viewBox="0 0 24 24" fill="currentColor">
           <path d="M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3zm-1-9c0-.55.45-1 1-1s1 .45 1 1v6c0 .55-.45 1-1 1s-1-.45-1-1V5zm6 6c0 2.76-2.24 5-5 5s-5-2.24-5-5H5c0 3.53 2.61 6.43 6 6.92V21h2v-3.08c3.39-.49 6-3.39 6-6.92h-2z"/>
         </svg>
         <svg v-else width="17" height="17" viewBox="0 0 24 24" fill="currentColor">
           <circle cx="12" cy="12" r="8" opacity="0.35"/><circle cx="12" cy="12" r="4"/>
         </svg>
-      </button>
+        </button>
+      </div>
 
       <!-- Abort (streaming) or Send -->
       <button
@@ -343,9 +475,50 @@ defineExpose({ focus, prefill })
 .btn-icon:hover { opacity: 1; }
 .btn-icon:disabled { opacity: 0.3; cursor: default; }
 
-.btn-mic.mic-recording { opacity: 1; color: #ef4444; }
+.btn-mic.mic-recording {
+  opacity: 1;
+  /* White icon sits on top of the red halo so it stays legible at any
+     pulse size. */
+  color: #fff;
+  position: relative;
+  z-index: 1;
+}
 .btn-mic.mic-transcribing { opacity: 0.5; }
 
+/* Mic wrapper + live amplitude halo. The glow is a filled red disc
+   absolutely positioned behind the button, scaled/faded by the
+   computed `micGlowStyle` so the user gets unmistakable feedback
+   that their voice is being picked up while the mic icon itself
+   stays put and readable on top. */
+.mic-wrapper {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+.mic-glow {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  background: radial-gradient(
+    circle,
+    rgba(239, 68, 68, 0.9) 0%,
+    rgba(239, 68, 68, 0.6) 55%,
+    rgba(239, 68, 68, 0) 100%
+  );
+  transform: translate(-50%, -50%) scale(1);
+  transform-origin: center;
+  pointer-events: none;
+  /* Smooth between amplitude samples (~100ms) so the pulse feels continuous
+     rather than stepping. */
+  transition: transform 0.12s ease-out, opacity 0.12s ease-out;
+  z-index: 0;
+}
+
 .note-picker-wrapper { position: relative; }
 .note-picker-dropdown {
   position: absolute;
@@ -391,7 +564,7 @@ defineExpose({ focus, prefill })
   display: flex;
   align-items: center;
   justify-content: center;
-  background: linear-gradient(135deg, #7c3aed, #5b21b6);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: 50%;
@@ -418,4 +591,77 @@ defineExpose({ focus, prefill })
   flex-shrink: 0;
 }
 .btn-abort-inline:hover { border-color: #ef4444; color: #ef4444; }
+
+/* Speaker / listen-mode popover */
+.speaker-wrapper { position: relative; display: inline-flex; flex-shrink: 0; }
+.btn-speaker.speaker-active { opacity: 1; color: var(--color-primary); }
+.btn-speaker.speaker-busy { opacity: 1; color: #f59e0b; }
+.speaker-popover {
+  position: absolute;
+  bottom: calc(100% + 8px);
+  right: 0;
+  min-width: 220px;
+  background: var(--color-bg-card);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  box-shadow: 0 4px 16px var(--color-shadow);
+  padding: 0.35rem;
+  z-index: 30;
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+}
+.speaker-row {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  padding: 0.45rem 0.6rem;
+  background: none;
+  border: none;
+  border-radius: var(--radius-sm);
+  color: var(--color-text);
+  font-size: 0.85rem;
+  cursor: default;
+  text-align: left;
+  width: 100%;
+}
+.speaker-row--toggle { cursor: pointer; }
+.speaker-row--toggle:hover { background: var(--color-bg-secondary); }
+.speaker-row--active { color: var(--color-primary); }
+.speaker-row--stop {
+  cursor: pointer;
+  color: var(--color-text-muted);
+  justify-content: flex-start;
+}
+.speaker-row--stop:hover { color: #ef4444; background: var(--color-bg-secondary); }
+.speaker-row-label { flex: 1; }
+.speaker-volume-range { flex: 1; min-width: 0; }
+.speaker-volume-pct {
+  font-size: 0.75rem;
+  color: var(--color-text-muted);
+  min-width: 2.5rem;
+  text-align: right;
+}
+.speaker-switch {
+  position: relative;
+  width: 28px;
+  height: 16px;
+  border-radius: 9999px;
+  background: var(--color-border);
+  transition: background 0.15s;
+  flex-shrink: 0;
+}
+.speaker-switch::after {
+  content: '';
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  width: 12px;
+  height: 12px;
+  border-radius: 50%;
+  background: var(--color-bg-card);
+  transition: transform 0.15s;
+}
+.speaker-switch.on { background: var(--color-primary); }
+.speaker-switch.on::after { transform: translateX(12px); }
 </style>

frontend/src/components/ChatMessage.vue

@@ -3,8 +3,16 @@ import { computed } from "vue";
 import { renderMarkdown } from "@/utils/markdown";
 import { useSettingsStore } from "@/stores/settings";
 import ToolCallCard from "@/components/ToolCallCard.vue";
+import BriefingToolStatusRow from "@/components/BriefingToolStatusRow.vue";
 import type { Message } from "@/types/chat";
 
+const SLOT_LABELS: Record<string, string> = {
+  compilation: "Full Briefing",
+  morning: "Morning Update",
+  midday: "Midday Update",
+  afternoon: "Afternoon Update",
+};
+
 const settingsStore = useSettingsStore();
 
 const props = defineProps<{
@@ -41,6 +49,30 @@ function formatMs(ms: number | null | undefined): string {
   return `${(ms / 1000).toFixed(1)}s`;
 }
 
+const metadata = computed(() => (props.message.metadata ?? {}) as Record<string, unknown>);
+
+const isBriefingIntermediate = computed(
+  () => props.message.role === "assistant" && metadata.value.briefing_intermediate === true,
+);
+
+const briefingSlot = computed(() => {
+  const slot = metadata.value.briefing_slot;
+  return typeof slot === "string" ? slot : null;
+});
+
+const slotLabel = computed(() => {
+  const slot = briefingSlot.value;
+  if (!slot) return null;
+  return SLOT_LABELS[slot] ?? slot;
+});
+
+const isSlotUpdate = computed(
+  () =>
+    !isBriefingIntermediate.value &&
+    briefingSlot.value != null &&
+    briefingSlot.value !== "compilation",
+);
+
 const timingParts = computed((): string[] => {
   const t = props.message.timing;
   if (!t) return [];
@@ -57,11 +89,16 @@ const timingParts = computed((): string[] => {
 </script>
 
 <template>
-  <div class="chat-message" :class="`role-${message.role}`">
+  <!-- Briefing intermediate: compact status row, no bubble -->
+  <div v-if="isBriefingIntermediate" class="chat-message role-assistant briefing-intermediate-row">
+    <BriefingToolStatusRow :tool-calls="message.tool_calls ?? []" />
+  </div>
+  <div v-else class="chat-message" :class="[`role-${message.role}`, { 'slot-update': isSlotUpdate }]">
     <div class="message-group">
-      <div class="message-bubble">
+      <div class="message-bubble" :class="{ 'bubble-slot': isSlotUpdate }">
         <div class="message-header">
           <span class="role-label">{{ roleLabel }}</span>
+          <span v-if="slotLabel" class="slot-badge" :class="{ 'slot-badge-update': isSlotUpdate }">{{ slotLabel }}</span>
           <div class="message-actions" v-if="message.role === 'assistant' && !isStreaming">
             <button class="btn-save" @click="emit('saveAsNote', message.id)" title="Save as note">
               Save as Note
@@ -281,4 +318,39 @@ details[open] .thinking-summary::before {
   margin-right: 0.2rem;
   opacity: 0.5;
 }
+
+/* ── Briefing intermediate row (no bubble) ──────────────── */
+.briefing-intermediate-row {
+  margin-bottom: 0.5rem;
+}
+
+/* ── Slot badge (morning/midday/afternoon/full) ─────────── */
+.slot-badge {
+  font-size: 0.65rem;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  padding: 0.1rem 0.45rem;
+  border-radius: 999px;
+  background: color-mix(in srgb, var(--color-primary) 14%, transparent);
+  color: var(--color-primary);
+  border: 1px solid color-mix(in srgb, var(--color-primary) 30%, transparent);
+  margin-left: 0.5rem;
+}
+.slot-badge-update {
+  background: color-mix(in srgb, var(--color-text-muted) 12%, transparent);
+  color: var(--color-text-muted);
+  border-color: var(--color-border);
+}
+
+/* ── Slot update bubbles: softer treatment than compilation ── */
+.slot-update .message-bubble.bubble-slot {
+  background: transparent;
+  border-left: 2px solid var(--color-border);
+  box-shadow: none;
+}
+.slot-update .message-bubble.bubble-slot .message-content {
+  font-size: 0.88rem;
+  color: var(--color-text-secondary);
+}
 </style>

frontend/src/components/ChatPanel.vue

@@ -1,11 +1,6 @@
 <script setup lang="ts">
-import { ref, computed, watch, nextTick, onMounted } from 'vue'
+import { ref, computed, watch, nextTick, onMounted, onUnmounted } from 'vue'
 import { useChatStore } from '@/stores/chat'
-import { useSettingsStore } from '@/stores/settings'
-import { useStreamingTts } from '@/composables/useStreamingTts'
-import { useVoiceAudio, setVoiceVolume } from '@/composables/useVoiceAudio'
-import { useListenMode } from '@/composables/useListenMode'
-import { apiGet } from '@/api/client'
 import ChatMessage from '@/components/ChatMessage.vue'
 import ChatStreamingBubble from '@/components/ChatStreamingBubble.vue'
 import ChatInputBar from '@/components/ChatInputBar.vue'
@@ -34,33 +29,6 @@ const emit = defineEmits<{
 }>()
 
 const store = useChatStore()
-const settingsStore = useSettingsStore()
-
-// ── Voice / TTS ───────────────────────────────────────────────────────────────
-const voiceTtsEnabled = computed(() => settingsStore.voiceTtsReady)
-const listenMode = useListenMode()
-const audio = useVoiceAudio()
-const showVolumeSlider = ref(false)
-
-const tts = useStreamingTts({
-  streamingContent: computed(() => store.streamingContent),
-  streaming: computed(() => store.streaming),
-  enabled: computed(() => listenMode.value && voiceTtsEnabled.value),
-})
-
-function lastAssistantContent(): string {
-  const msgs = store.currentConversation?.messages ?? []
-  return [...msgs].reverse().find((m) => m.role === 'assistant')?.content ?? ''
-}
-
-function toggleListen() {
-  listenMode.value = !listenMode.value
-  if (listenMode.value) {
-    tts.speak(lastAssistantContent())
-  } else {
-    tts.stop()
-  }
-}
 
 // ── Scroll ────────────────────────────────────────────────────────────────────
 const messagesEl = ref<HTMLElement | null>(null)
@@ -89,47 +57,6 @@ watch(() => store.streamingToolCalls, (calls) => {
 }, { deep: true })
 watch(() => store.streaming, (s) => { if (!s) _seenCalendarToolIdx.clear() })
 
-// ── RAG scope chip (full, non-briefing, non-workspace) ────────────────────────
-const projects = ref<{ id: number; title: string }[]>([])
-const scopeDropdownOpen = ref(false)
-const scopePulse = ref(false)
-
-const showScopeChip = computed(
-  () => props.variant === 'full' && !props.briefingMode && !props.projectId
-)
-
-const scopeLabel = computed(() => {
-  const id = store.ragProjectId
-  if (id === -1) return 'All notes'
-  if (id === null) return 'Orphan notes'
-  return projects.value.find((p) => p.id === id)?.title ?? `Project ${id}`
-})
-
-async function loadProjects() {
-  try {
-    const data = await apiGet<{ projects: { id: number; title: string }[] }>('/api/projects?status=active')
-    projects.value = data.projects ?? []
-  } catch {
-    projects.value = []
-  }
-}
-
-async function onScopeSelect(value: number | null) {
-  scopeDropdownOpen.value = false
-  const convId = store.currentConversation?.id
-  if (!convId) return
-  await store.updateRagScope(convId, value)
-  scopePulse.value = true
-  setTimeout(() => { scopePulse.value = false }, 600)
-}
-
-// Pulse when model-driven scope change fires
-watch(() => store.ragProjectId, () => {
-  if (!showScopeChip.value) return
-  scopePulse.value = true
-  setTimeout(() => { scopePulse.value = false }, 600)
-})
-
 // ── Note context (full variant — included / suggested / auto-injected notes) ──
 const includedNoteIds = ref<Set<number>>(new Set())
 const includedNotes = ref<{ id: number; title: string }[]>([])
@@ -190,11 +117,92 @@ function removeIncludedNote(noteId: number) {
   }
 }
 
-const hasContextSidebar = computed(
-  () => props.variant === 'full' && !props.briefingMode && !props.projectId &&
-    (autoInjectedNotes.value.length > 0 || includedNotes.value.length > 0 || suggestedNotes.value.length > 0)
+const contextCount = computed(
+  () => autoInjectedNotes.value.length + suggestedNotes.value.length + includedNotes.value.length
 )
 
+const hasContextData = computed(
+  () => props.variant === 'full' && !props.briefingMode && !props.projectId && contextCount.value > 0
+)
+
+// ── Narrow-viewport sidebar toggle ────────────────────────────────────────────
+const NARROW_BREAKPOINT = 1200
+const isNarrow = ref(typeof window !== 'undefined' && window.innerWidth < NARROW_BREAKPOINT)
+const sidebarOpen = ref(false)
+
+function onResize() {
+  isNarrow.value = window.innerWidth < NARROW_BREAKPOINT
+}
+onMounted(() => window.addEventListener('resize', onResize))
+onUnmounted(() => window.removeEventListener('resize', onResize))
+
+function toggleContextSidebar() {
+  sidebarOpen.value = !sidebarOpen.value
+}
+
+const hasContextSidebar = computed(() => hasContextData.value && sidebarOpen.value)
+
+// ── Collapsible sections (per-conversation, localStorage) ─────────────────────
+type SectionKey = 'auto' | 'suggested' | 'included'
+const collapsedSections = ref<Set<SectionKey>>(new Set())
+
+function storageKey(): string | null {
+  const id = store.currentConversation?.id
+  return id ? `fa_chat_ctx_collapsed_${id}` : null
+}
+
+function loadCollapsed() {
+  const key = storageKey()
+  if (!key) { collapsedSections.value = new Set(); return }
+  try {
+    const raw = localStorage.getItem(key)
+    if (!raw) { collapsedSections.value = new Set(); return }
+    const arr = JSON.parse(raw) as SectionKey[]
+    collapsedSections.value = new Set(arr)
+  } catch {
+    collapsedSections.value = new Set()
+  }
+}
+
+function saveCollapsed() {
+  const key = storageKey()
+  if (!key) return
+  try {
+    localStorage.setItem(key, JSON.stringify([...collapsedSections.value]))
+  } catch { /* ignore */ }
+}
+
+function toggleSection(key: SectionKey) {
+  const next = new Set(collapsedSections.value)
+  if (next.has(key)) next.delete(key)
+  else next.add(key)
+  collapsedSections.value = next
+  saveCollapsed()
+}
+
+watch(() => store.currentConversation?.id, () => loadCollapsed(), { immediate: true })
+
+// ── Empty-state (full variant, fresh/empty conversation) ─────────────────────
+const showEmptyState = computed(
+  () =>
+    props.variant === 'full'
+    && !props.briefingMode
+    && !props.projectId
+    && !store.streaming
+    && (store.currentConversation?.messages.length ?? 0) === 0
+)
+
+const recentConversations = computed(() => {
+  const currentId = store.currentConversation?.id
+  return store.conversations
+    .filter((c) => c.id !== currentId && c.message_count > 0)
+    .slice(0, 5)
+})
+
+function startVoiceMode() {
+  window.dispatchEvent(new CustomEvent('voice:ptt-toggle'))
+}
+
 // ── Send ──────────────────────────────────────────────────────────────────────
 const inputBarRef = ref<InstanceType<typeof ChatInputBar> | null>(null)
 
@@ -208,7 +216,7 @@ async function onSubmit(payload: { content: string; contextNoteId?: number }) {
     payload.content,
     payload.contextNoteId,
     includedNoteIds.value.size ? [...includedNoteIds.value] : undefined,
-    true,
+    false,
     undefined,
     excludedNoteIds.value.length ? excludedNoteIds.value : undefined,
     props.projectId ?? store.ragProjectId,
@@ -249,7 +257,7 @@ async function widgetSend(payload: { content: string; contextNoteId?: number })
   widgetConvId.value = conv.id
   emit('conversation-started', conv.id)
 
-  await store.sendMessage(payload.content, payload.contextNoteId, undefined, true)
+  await store.sendMessage(payload.content, payload.contextNoteId, undefined, false)
 
   const msgs = store.currentConversation?.messages ?? []
   const lastAssistant = [...msgs].reverse().find((m: Message) => m.role === 'assistant')
@@ -271,8 +279,7 @@ async function handleSaveAsNote(messageId: number) {
 }
 
 // ── Lifecycle ─────────────────────────────────────────────────────────────────
-onMounted(async () => {
-  if (showScopeChip.value) await loadProjects()
+onMounted(() => {
   if (props.autoFocus) nextTick(() => inputBarRef.value?.focus())
 })
 
@@ -289,13 +296,30 @@ async function send(text: string) {
   await onSubmit({ content: text })
 }
 
-defineExpose({ focus, prefill, send })
+// ── Briefing slot separator helper ────────────────────────────────────────────
+function hasEarlierBriefingSlot(index: number): boolean {
+  const msgs = store.currentConversation?.messages ?? []
+  for (let i = 0; i < index; i++) {
+    const m = msgs[i]
+    const meta = m?.metadata as Record<string, unknown> | null | undefined
+    if (
+      m?.role === 'assistant' &&
+      meta?.briefing_slot != null &&
+      !meta?.briefing_intermediate
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+defineExpose({ focus, prefill, send, contextCount, sidebarOpen, toggleContextSidebar, hasContextData })
 </script>
 
 <template>
   <!-- ═══════════════════════════════ FULL VARIANT ══════════════════════════════ -->
   <template v-if="variant === 'full'">
-    <div class="chat-body" :class="{ 'chat-body--has-sidebar': hasContextSidebar }">
+    <div class="chat-full">
       <!-- Message list -->
       <div ref="messagesEl" class="messages-container">
         <div class="messages-inner">
@@ -303,13 +327,11 @@ defineExpose({ focus, prefill, send })
             v-for="(msg, index) in store.currentConversation?.messages ?? []"
             :key="msg.id"
           >
-            <!-- Briefing slot separator: shown before a 2nd+ briefing slot message -->
+            <!-- Briefing slot separator: before any non-first slot message (skip intermediate tool-call rows) -->
             <div
-              v-if="briefingMode && index > 0 && msg.role === 'assistant' && msg.metadata?.rss_item_ids"
+              v-if="briefingMode && msg.role === 'assistant' && msg.metadata?.briefing_slot && !msg.metadata?.briefing_intermediate && hasEarlierBriefingSlot(index)"
               class="briefing-slot-separator"
-            >
-              <span>New Briefing Update</span>
-            </div>
+            ></div>
             <ChatMessage
               :message="msg"
               @save-as-note="handleSaveAsNote"
@@ -335,8 +357,27 @@ defineExpose({ focus, prefill, send })
               </button>
             </div>
           </template>
+          <div v-if="showEmptyState" class="chat-empty-state">
+            <h2 class="empty-greeting">What's on your mind?</h2>
+            <div v-if="recentConversations.length" class="empty-recent">
+              <div class="empty-section-label">Jump back in</div>
+              <router-link
+                v-for="conv in recentConversations"
+                :key="conv.id"
+                :to="`/chat/${conv.id}`"
+                class="empty-recent-item"
+              >
+                <span class="empty-recent-title">{{ conv.title || 'Untitled conversation' }}</span>
+                <span class="empty-recent-count">{{ conv.message_count }} msg</span>
+              </router-link>
+            </div>
+            <button class="empty-voice-btn" @click="startVoiceMode" title="Start in voice mode">
+              <span class="voice-icon">🎤</span>
+              <span>Start in voice mode</span>
+            </button>
+          </div>
           <p
-            v-if="!store.currentConversation?.messages.length && !store.streaming"
+            v-else-if="!store.currentConversation?.messages.length && !store.streaming"
             class="empty-msg"
           >Start a conversation.</p>
         </div>
@@ -345,114 +386,71 @@ defineExpose({ focus, prefill, send })
       <!-- Context sidebar (full, non-briefing, non-workspace) -->
       <aside v-if="hasContextSidebar" class="context-sidebar">
         <template v-if="autoInjectedNotes.length">
-          <div class="context-sidebar-header">Auto-included</div>
-          <div v-for="note in autoInjectedNotes" :key="note.id" class="context-note context-note-auto">
-            <router-link :to="`/notes/${note.id}`" class="context-note-name">{{ note.title }}</router-link>
-            <span
-              v-if="note.score != null"
-              class="context-note-score"
-              :class="{ 'score-high': note.score >= 0.75, 'score-medium': note.score >= 0.60 && note.score < 0.75, 'score-low': note.score < 0.60 }"
-            >{{ Math.round(note.score * 100) }}%</span>
-            <button class="context-note-remove" @click="excludeAutoNote(note.id)">&times;</button>
+          <button
+            class="context-sidebar-header"
+            :class="{ collapsed: collapsedSections.has('auto') }"
+            @click="toggleSection('auto')"
+          >
+            <svg class="chev" width="10" height="10" viewBox="0 0 10 10" fill="currentColor"><path d="M2 3l3 4 3-4z"/></svg>
+            <span>Auto-included</span>
+            <span class="section-count">{{ autoInjectedNotes.length }}</span>
+          </button>
+          <div v-show="!collapsedSections.has('auto')">
+            <div v-for="note in autoInjectedNotes" :key="note.id" class="context-note context-note-auto">
+              <span class="auto-pill" title="Auto-included by relevance">AUTO</span>
+              <router-link :to="`/notes/${note.id}`" class="context-note-name">{{ note.title }}</router-link>
+              <span
+                v-if="note.score != null"
+                class="context-note-score"
+                :class="{ 'score-high': note.score >= 0.75, 'score-medium': note.score >= 0.60 && note.score < 0.75, 'score-low': note.score < 0.60 }"
+              >{{ Math.round(note.score * 100) }}%</span>
+              <button class="context-note-remove" @click="excludeAutoNote(note.id)" title="Remove from context">&times;</button>
+            </div>
           </div>
         </template>
         <template v-if="suggestedNotes.length">
-          <div class="context-sidebar-header" :class="{ 'context-sidebar-header-gap': autoInjectedNotes.length }">Suggested</div>
-          <div v-for="note in suggestedNotes" :key="note.id" class="context-note context-note-suggested">
-            <router-link :to="`/notes/${note.id}`" class="context-note-name">{{ note.title }}</router-link>
-            <span
-              v-if="note.score != null"
-              class="context-note-score"
-              :class="{ 'score-high': note.score >= 0.75, 'score-medium': note.score >= 0.60 && note.score < 0.75, 'score-low': note.score < 0.60 }"
-            >{{ Math.round(note.score * 100) }}%</span>
-            <button class="context-note-add" @click="includeNote(note)" title="Add to context">+</button>
+          <button
+            class="context-sidebar-header"
+            :class="{ collapsed: collapsedSections.has('suggested'), 'context-sidebar-header-gap': autoInjectedNotes.length }"
+            @click="toggleSection('suggested')"
+          >
+            <svg class="chev" width="10" height="10" viewBox="0 0 10 10" fill="currentColor"><path d="M2 3l3 4 3-4z"/></svg>
+            <span>Suggested</span>
+            <span class="section-count">{{ suggestedNotes.length }}</span>
+          </button>
+          <div v-show="!collapsedSections.has('suggested')">
+            <div v-for="note in suggestedNotes" :key="note.id" class="context-note context-note-suggested">
+              <router-link :to="`/notes/${note.id}`" class="context-note-name">{{ note.title }}</router-link>
+              <span
+                v-if="note.score != null"
+                class="context-note-score"
+                :class="{ 'score-high': note.score >= 0.75, 'score-medium': note.score >= 0.60 && note.score < 0.75, 'score-low': note.score < 0.60 }"
+              >{{ Math.round(note.score * 100) }}%</span>
+              <button class="context-note-add" @click="includeNote(note)" title="Add to context">+</button>
+            </div>
           </div>
         </template>
         <template v-if="includedNotes.length">
-          <div class="context-sidebar-header" :class="{ 'context-sidebar-header-gap': autoInjectedNotes.length || suggestedNotes.length }">In Context</div>
-          <div v-for="note in includedNotes" :key="note.id" class="context-note context-note-included">
-            <router-link :to="`/notes/${note.id}`" class="context-note-name">{{ note.title }}</router-link>
-            <button class="context-note-remove" @click="removeIncludedNote(note.id)">&times;</button>
+          <button
+            class="context-sidebar-header"
+            :class="{ collapsed: collapsedSections.has('included'), 'context-sidebar-header-gap': autoInjectedNotes.length || suggestedNotes.length }"
+            @click="toggleSection('included')"
+          >
+            <svg class="chev" width="10" height="10" viewBox="0 0 10 10" fill="currentColor"><path d="M2 3l3 4 3-4z"/></svg>
+            <span>In Context</span>
+            <span class="section-count">{{ includedNotes.length }}</span>
+          </button>
+          <div v-show="!collapsedSections.has('included')">
+            <div v-for="note in includedNotes" :key="note.id" class="context-note context-note-included">
+              <router-link :to="`/notes/${note.id}`" class="context-note-name">{{ note.title }}</router-link>
+              <button class="context-note-remove" @click="removeIncludedNote(note.id)" title="Remove from context">&times;</button>
+            </div>
           </div>
         </template>
       </aside>
-    </div>
-
-    <!-- Input area (hidden when readOnly) -->
-    <div v-if="!readOnly" class="input-wrapper">
-      <!-- Scope chip -->
-      <div v-if="showScopeChip" class="scope-chip-row">
-        <div class="scope-chip-wrapper">
-          <button
-            class="scope-chip"
-            :class="{ pulse: scopePulse }"
-            @click="scopeDropdownOpen = !scopeDropdownOpen"
-            title="Change RAG scope"
-          >
-            <span class="scope-dot">⊙</span> {{ scopeLabel }}
-          </button>
-          <div v-if="scopeDropdownOpen" class="scope-dropdown">
-            <button class="scope-option" :class="{ active: store.ragProjectId === null }" @click="onScopeSelect(null)">Orphan notes only</button>
-            <button
-              v-for="p in projects"
-              :key="p.id"
-              class="scope-option"
-              :class="{ active: store.ragProjectId === p.id }"
-              @click="onScopeSelect(p.id)"
-            >{{ p.title }}</button>
-            <button class="scope-option" :class="{ active: store.ragProjectId === -1 }" @click="onScopeSelect(-1)">All notes</button>
-          </div>
-        </div>
-      </div>
-
-      <!-- Listen / volume controls -->
-      <div v-if="voiceTtsEnabled" class="voice-controls">
-        <div class="volume-wrapper">
-          <button
-            class="btn-voice"
-            :class="{ 'btn-voice--active': listenMode, 'btn-voice--busy': tts.speaking.value }"
-            @click="toggleListen"
-            :title="listenMode ? 'Stop auto-read' : 'Read responses aloud'"
-            aria-label="Toggle listen mode"
-          >
-            <svg v-if="!tts.speaking.value" width="17" height="17" viewBox="0 0 24 24" fill="currentColor">
-              <path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z"/>
-            </svg>
-            <svg v-else width="17" height="17" viewBox="0 0 24 24" fill="currentColor">
-              <path d="M18 12c0-1.77-1.02-3.29-2.5-4.03v2.21l2.45 2.45c.03-.2.05-.41.05-.63zm2.5 0c0 .94-.2 1.82-.54 2.64l1.51 1.51C21.8 14.82 22 13.43 22 12c0-4.28-2.99-7.86-7-8.77v2.06c2.89.86 5 3.54 5 6.71zM4.27 3L3 4.27 7.73 9H3v6h4l5 5v-6.73l4.25 4.25c-.67.52-1.42.93-2.25 1.18v2.06c1.38-.31 2.63-.95 3.69-1.81L19.73 21 21 19.73l-9-9L4.27 3zM12 4L9.91 6.09 12 8.18V4z"/>
-            </svg>
-          </button>
-          <button
-            class="btn-voice btn-volume-icon"
-            @click="showVolumeSlider = !showVolumeSlider"
-            :title="`Volume: ${Math.round(audio.volume.value * 100)}%`"
-            aria-label="Volume"
-          >
-            <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
-              <path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02z"/>
-            </svg>
-          </button>
-          <div v-if="showVolumeSlider" class="volume-popup">
-            <input
-              type="range" min="0" max="1" step="0.05"
-              :value="audio.volume.value"
-              @input="setVoiceVolume(+($event.target as HTMLInputElement).value)"
-              class="volume-range"
-              aria-label="Volume"
-            />
-            <span class="volume-pct">{{ Math.round(audio.volume.value * 100) }}%</span>
-          </div>
-        </div>
-        <button
-          v-if="tts.speaking.value"
-          class="btn-voice"
-          @click="tts.stop()"
-          title="Stop playback"
-        >
-          <svg width="13" height="13" viewBox="0 0 14 14" fill="currentColor"><rect width="14" height="14" rx="2"/></svg>
-        </button>
-      </div>
 
+      <!-- Input area (hidden when readOnly) -->
+      <div v-if="!readOnly" class="input-wrapper">
       <!-- Unified input bar -->
       <ChatInputBar
         ref="inputBarRef"
@@ -461,6 +459,7 @@ defineExpose({ focus, prefill, send })
         @submit="onSubmit"
         @abort="store.cancelGeneration()"
       />
+      </div>
     </div>
   </template>
 
@@ -513,18 +512,31 @@ defineExpose({ focus, prefill, send })
 </template>
 
 <style scoped>
-/* ── Full variant layout ── */
-.chat-body {
+/* ── Full variant layout ──
+ * Single grid owns the reading column + context sidebar + input bar so
+ * messages and input bar share one centered reading track while the
+ * context sidebar spans the full height from header to bottom of view.
+ * Reading column is always centered (3-column grid: 1fr | content | 1fr).
+ * The context sidebar overlays the right gutter so it never shifts layout.
+ */
+.chat-full {
+  position: relative;
   flex: 1;
-  display: flex;
   min-height: 0;
+  display: grid;
+  grid-template-columns:
+    1fr
+    minmax(0, var(--chat-reading-width))
+    1fr;
+  grid-template-rows: minmax(0, 1fr) auto;
   overflow: hidden;
 }
 
 .messages-container {
-  flex: 1;
+  grid-column: 2;
+  grid-row: 1;
   overflow-y: auto;
-  padding: 1rem;
+  padding: 1rem 1rem 0.75rem;
   mask-image: linear-gradient(to bottom, transparent, black 20px, black calc(100% - 20px), transparent);
   -webkit-mask-image: linear-gradient(to bottom, transparent, black 20px, black calc(100% - 20px), transparent);
 }
@@ -537,51 +549,85 @@ defineExpose({ focus, prefill, send })
 
 /* Briefing slot separator */
 .briefing-slot-separator {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  margin: 1.25rem 0 0.5rem;
-  color: var(--color-text-muted, #888);
-  font-size: 0.7rem;
-  font-weight: 600;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  opacity: 0.7;
-}
-.briefing-slot-separator::before,
-.briefing-slot-separator::after {
-  content: '';
-  flex: 1;
   height: 1px;
+  margin: 1.25rem 0 0.75rem;
   background: var(--color-border, #333);
-  opacity: 0.5;
+  opacity: 0.35;
 }
 
-/* Context sidebar */
+/* Context sidebar — overlays right gutter, never shifts reading column */
 .context-sidebar {
-  width: 200px;
-  min-width: 160px;
-  max-width: 220px;
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  width: var(--chat-context-sidebar-width);
   border-left: 1px solid var(--color-border);
   padding: 0.75rem 0.5rem;
   overflow-y: auto;
   background: var(--color-bg-secondary);
   font-size: 0.78rem;
+  z-index: 2;
 }
 .context-sidebar-header {
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+  width: 100%;
+  background: none;
+  border: none;
+  padding: 0.15rem 0.1rem;
+  font-family: inherit;
   font-size: 0.65rem;
   font-weight: 700;
   text-transform: uppercase;
   letter-spacing: 0.05em;
   color: var(--color-text-muted);
   margin-bottom: 0.35rem;
+  cursor: pointer;
+  text-align: left;
+}
+.context-sidebar-header:hover { color: var(--color-text); }
+.context-sidebar-header .chev {
+  transition: transform 0.15s ease;
+}
+.context-sidebar-header.collapsed .chev {
+  transform: rotate(-90deg);
+}
+.context-sidebar-header .section-count {
+  margin-left: auto;
+  color: var(--color-text-muted);
+  font-weight: 600;
+  background: var(--color-bg);
+  padding: 0.05rem 0.3rem;
+  border-radius: 8px;
 }
 .context-sidebar-header-gap { margin-top: 0.75rem; }
 .context-note {
   display: flex;
   align-items: center;
-  gap: 0.2rem;
+  gap: 0.25rem;
   margin-bottom: 0.25rem;
+  padding: 0.2rem 0.35rem;
+  border-radius: var(--radius-sm);
+}
+.context-note-auto {
+  background: color-mix(in srgb, var(--color-text-muted) 8%, transparent);
+  opacity: 0.85;
+}
+.context-note-included {
+  background: color-mix(in srgb, var(--color-primary) 10%, transparent);
+  border-left: 2px solid var(--color-primary);
+}
+.auto-pill {
+  font-size: 0.55rem;
+  font-weight: 700;
+  letter-spacing: 0.05em;
+  padding: 0.05rem 0.3rem;
+  border-radius: 4px;
+  background: var(--color-bg);
+  color: var(--color-text-muted);
+  flex-shrink: 0;
 }
 .context-note-name {
   flex: 1;
@@ -615,103 +661,16 @@ defineExpose({ focus, prefill, send })
 .context-note-remove:hover { color: #ef4444; }
 .context-note-add:hover { color: var(--color-primary); }
 
-/* Input wrapper */
+/* Input wrapper — lives in the same reading column as messages */
 .input-wrapper {
-  border-top: 1px solid var(--color-border);
+  grid-column: 2;
+  grid-row: 2;
   padding: 0.5rem 1rem 0.75rem;
   display: flex;
   flex-direction: column;
   gap: 0.4rem;
 }
 
-/* Scope chip */
-.scope-chip-row { display: flex; }
-.scope-chip-wrapper { position: relative; }
-.scope-chip {
-  display: flex;
-  align-items: center;
-  gap: 0.3rem;
-  background: none;
-  border: 1px solid var(--color-border);
-  border-radius: 20px;
-  padding: 0.2rem 0.65rem;
-  font-size: 0.75rem;
-  color: var(--color-text-muted);
-  cursor: pointer;
-  transition: border-color 0.15s, color 0.15s;
-}
-.scope-chip:hover { border-color: var(--color-primary); color: var(--color-primary); }
-.scope-chip.pulse { animation: pulse-chip 0.6s ease; }
-@keyframes pulse-chip {
-  0%, 100% { border-color: var(--color-border); }
-  50% { border-color: var(--color-primary); color: var(--color-primary); box-shadow: 0 0 6px rgba(99,102,241,0.4); }
-}
-.scope-dot { font-size: 0.6rem; }
-.scope-dropdown {
-  position: absolute;
-  top: calc(100% + 4px);
-  left: 0;
-  min-width: 180px;
-  background: var(--color-bg-card);
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-md);
-  box-shadow: 0 4px 16px var(--color-shadow);
-  z-index: 20;
-  overflow: hidden;
-}
-.scope-option {
-  display: block;
-  width: 100%;
-  padding: 0.45rem 0.75rem;
-  text-align: left;
-  background: none;
-  border: none;
-  font-size: 0.85rem;
-  color: var(--color-text);
-  cursor: pointer;
-}
-.scope-option:hover { background: var(--color-bg-secondary); }
-.scope-option.active { color: var(--color-primary); font-weight: 600; }
-
-/* Voice controls */
-.voice-controls {
-  display: flex;
-  align-items: center;
-  gap: 0.2rem;
-}
-.volume-wrapper { position: relative; display: flex; align-items: center; gap: 0.1rem; }
-.btn-voice {
-  background: none;
-  border: none;
-  cursor: pointer;
-  color: var(--color-text-muted);
-  opacity: 0.65;
-  padding: 0.2rem;
-  display: flex;
-  align-items: center;
-  border-radius: var(--radius-sm);
-  transition: opacity 0.15s, color 0.15s;
-}
-.btn-voice:hover { opacity: 1; }
-.btn-voice--active { opacity: 1; color: var(--color-primary); }
-.btn-voice--busy { opacity: 1; color: #f59e0b; }
-.volume-popup {
-  position: absolute;
-  bottom: calc(100% + 8px);
-  left: 0;
-  background: var(--color-bg-card);
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-md);
-  padding: 0.5rem 0.75rem;
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  z-index: 20;
-  box-shadow: 0 4px 16px var(--color-shadow);
-}
-.volume-range { width: 80px; }
-.volume-pct { font-size: 0.75rem; color: var(--color-text-muted); white-space: nowrap; }
-
 /* Queued messages */
 .queued-message { opacity: 0.45; }
 .queued-bubble {
@@ -753,6 +712,108 @@ defineExpose({ focus, prefill, send })
   color: var(--color-accent-warm, #d4a017);
 }
 
+.chat-empty-state {
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  gap: 1.5rem;
+  padding: 3rem 1rem 2rem;
+  max-width: 520px;
+  margin: 0 auto;
+}
+
+.empty-greeting {
+  font-family: 'Fraunces', Georgia, serif;
+  font-style: italic;
+  font-weight: 400;
+  font-size: 1.75rem;
+  color: var(--color-accent-warm, #d4a017);
+  text-align: center;
+  margin: 0;
+}
+
+.empty-section-label {
+  font-size: 0.7rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--color-text-muted);
+  margin-bottom: 0.5rem;
+  padding-left: 0.25rem;
+}
+
+.empty-recent {
+  display: flex;
+  flex-direction: column;
+}
+
+.empty-recent-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+  padding: 0.75rem 0.9rem;
+  border-radius: var(--radius-md, 10px);
+  border: 1px solid var(--color-border);
+  background: var(--color-bg-elevated, rgba(255, 255, 255, 0.02));
+  color: var(--color-text);
+  text-decoration: none;
+  font-size: 0.9rem;
+  transition: border-color 0.15s ease, background 0.15s ease, transform 0.15s ease;
+}
+
+.empty-recent-item + .empty-recent-item {
+  margin-top: 0.4rem;
+}
+
+.empty-recent-item:hover {
+  border-color: var(--color-primary);
+  background: rgba(99, 102, 241, 0.05);
+  transform: translateX(2px);
+}
+
+.empty-recent-title {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  flex: 1;
+  min-width: 0;
+}
+
+.empty-recent-count {
+  font-size: 0.7rem;
+  color: var(--color-text-muted);
+  font-variant-numeric: tabular-nums;
+  flex-shrink: 0;
+}
+
+.empty-voice-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.6rem;
+  padding: 0.75rem 1.2rem;
+  border-radius: 999px;
+  border: 1px solid var(--color-border);
+  background: transparent;
+  color: var(--color-text);
+  font-size: 0.9rem;
+  cursor: pointer;
+  align-self: center;
+  transition: border-color 0.15s ease, background 0.15s ease, color 0.15s ease;
+}
+
+.empty-voice-btn:hover {
+  border-color: var(--color-primary);
+  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  color: #fff;
+  box-shadow: 0 4px 16px rgba(99, 102, 241, 0.35);
+}
+
+.empty-voice-btn .voice-icon {
+  font-size: 1.05rem;
+}
+
 /* ── Widget variant ── */
 .widget-response {
   margin-top: 0.75rem;

frontend/src/components/EventSlideOver.vue

@@ -64,36 +64,114 @@ function toIso(date: string, time: string): string {
   return `${date}T${time}:00${sign}${h}:${min}`;
 }
 
+// ── Time helpers ──────────────────────────────────────────────────────────────
+
+/** Round up to next 30-minute boundary */
+function nextRoundedTime(): string {
+  const now = new Date();
+  let h = now.getHours();
+  let m = now.getMinutes();
+  if (m <= 30) { m = 30; }
+  else { m = 0; h = (h + 1) % 24; }
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+
+/** Add hours to a time string (HH:MM), returns HH:MM */
+function addHours(time: string, hours: number): string {
+  const [h, m] = time.split(":").map(Number);
+  const totalMin = h * 60 + m + hours * 60;
+  const nh = Math.floor(totalMin / 60) % 24;
+  const nm = totalMin % 60;
+  return `${String(nh).padStart(2, "0")}:${String(nm).padStart(2, "0")}`;
+}
+
+/** Duration in minutes between two time strings */
+function durationMin(start: string, end: string): number {
+  const [sh, sm] = start.split(":").map(Number);
+  const [eh, em] = end.split(":").map(Number);
+  return (eh * 60 + em) - (sh * 60 + sm);
+}
+
+/** True if a date+time is in the past */
+const isPastEvent = computed(() => {
+  if (allDay.value || !startDate.value || !startTime.value) return false;
+  const dt = new Date(`${startDate.value}T${startTime.value}:00`);
+  return dt.getTime() < Date.now();
+});
+
+// Track duration so end moves with start
+let _lastDurationMin = 60;
+
 function resetForm() {
   if (props.event) {
     title.value = props.event.title;
     allDay.value = props.event.all_day;
-    // All-day events: use UTC date string directly to avoid timezone shifting
-    // (UTC midnight parsed through new Date() becomes the previous day in UTC-X zones)
     startDate.value = props.event.all_day ? props.event.start_dt.slice(0, 10) : dateFromIso(props.event.start_dt);
     startTime.value = props.event.all_day ? "" : timeFromIso(props.event.start_dt);
-    endDate.value = props.event.end_dt ? (props.event.all_day ? props.event.end_dt.slice(0, 10) : dateFromIso(props.event.end_dt)) : "";
-    endTime.value = props.event.end_dt && !props.event.all_day ? timeFromIso(props.event.end_dt) : "";
+    endDate.value = props.event.end_dt ? (props.event.all_day ? props.event.end_dt.slice(0, 10) : dateFromIso(props.event.end_dt)) : startDate.value;
+    endTime.value = props.event.end_dt && !props.event.all_day ? timeFromIso(props.event.end_dt) : addHours(startTime.value || "09:00", 1);
     description.value = props.event.description || "";
     location.value = props.event.location || "";
     color.value = props.event.color || "";
     projectId.value = props.event.project_id;
+    _lastDurationMin = !allDay.value && startTime.value && endTime.value ? durationMin(startTime.value, endTime.value) : 60;
+    if (_lastDurationMin <= 0) _lastDurationMin = 60;
   } else {
     title.value = "";
     allDay.value = false;
     const base = props.initialDate ? dateFromIso(props.initialDate) : new Date().toISOString().slice(0, 10);
+    const roundedStart = nextRoundedTime();
     startDate.value = base;
-    startTime.value = "09:00";
+    startTime.value = roundedStart;
     endDate.value = base;
-    endTime.value = "10:00";
+    endTime.value = addHours(roundedStart, 1);
     description.value = "";
     location.value = "";
     color.value = "";
     projectId.value = null;
+    _lastDurationMin = 60;
   }
   deleteConfirm.value = false;
 }
 
+// When start time changes, move end time to preserve duration
+watch(startTime, (newStart) => {
+  if (allDay.value || !newStart) return;
+  endTime.value = addHours(newStart, _lastDurationMin / 60);
+});
+
+// When start date changes, move end date to match (preserve same-day or multi-day gap)
+watch(startDate, (newDate) => {
+  if (!newDate) return;
+  endDate.value = newDate;
+});
+
+// When end time changes manually, update the tracked duration (but guard against end < start)
+watch(endTime, (newEnd) => {
+  if (allDay.value || !newEnd || !startTime.value) return;
+  const dur = durationMin(startTime.value, newEnd);
+  if (dur <= 0) {
+    // Snap back to start + 1 hour
+    endTime.value = addHours(startTime.value, 1);
+    _lastDurationMin = 60;
+  } else {
+    _lastDurationMin = dur;
+  }
+});
+
+// All-day toggle: clear/restore times
+watch(allDay, (isAllDay) => {
+  if (isAllDay) {
+    startTime.value = "";
+    endTime.value = "";
+  } else {
+    const rounded = nextRoundedTime();
+    startTime.value = rounded;
+    endTime.value = addHours(rounded, 1);
+    _lastDurationMin = 60;
+  }
+});
+
 watch(() => props.event, resetForm, { immediate: true });
 watch(() => props.initialDate, resetForm);
 
@@ -113,6 +191,10 @@ async function save() {
     toast.show("Start date is required", "error");
     return;
   }
+  if (!allDay.value && !startTime.value) {
+    toast.show("Start time is required", "error");
+    return;
+  }
 
   const start_dt = allDay.value ? `${startDate.value}T00:00:00` : toIso(startDate.value, startTime.value);
   const end_dt = endDate.value
@@ -199,18 +281,19 @@ async function doDelete() {
 
           <!-- Start -->
           <div class="so-field">
-            <label class="so-label">Start</label>
+            <label class="so-label">Start <span class="required">*</span></label>
             <div class="dt-row">
-              <input v-model="startDate" type="date" class="so-input dt-date" />
-              <input v-if="!allDay" v-model="startTime" type="time" class="so-input dt-time" />
+              <input v-model="startDate" type="date" class="so-input dt-date" required />
+              <input v-if="!allDay" v-model="startTime" type="time" class="so-input dt-time" required />
             </div>
+            <p v-if="isPastEvent" class="so-past-hint">This event is in the past</p>
           </div>
 
           <!-- End -->
           <div class="so-field">
-            <label class="so-label">End <span class="so-hint">(optional)</span></label>
+            <label class="so-label">End</label>
             <div class="dt-row">
-              <input v-model="endDate" type="date" class="so-input dt-date" />
+              <input v-model="endDate" type="date" class="so-input dt-date" :min="startDate" />
               <input v-if="!allDay" v-model="endTime" type="time" class="so-input dt-time" />
             </div>
           </div>
@@ -232,7 +315,7 @@ async function doDelete() {
             <label class="so-label so-label-inline">Color</label>
             <div class="color-row">
               <input v-model="color" type="color" class="color-picker" title="Pick event color" />
-              <input v-model="color" class="so-input color-hex" placeholder="#6366f1" />
+              <input v-model="color" class="so-input color-hex" placeholder="#7c3aed" />
               <button v-if="color" type="button" class="btn-clear-color" @click="color = ''">✕</button>
             </div>
           </div>
@@ -357,13 +440,19 @@ async function doDelete() {
   box-sizing: border-box;
   transition: border-color 0.15s;
 }
-.so-input:focus { outline: none; border-color: var(--color-primary, #6366f1); }
+.so-input:focus { outline: none; border-color: var(--color-primary); }
 
 .so-textarea { resize: vertical; min-height: 5rem; font-family: inherit; }
 
 .dt-row { display: flex; gap: 0.5rem; }
 .dt-date { flex: 1; }
 .dt-time { width: 7.5rem; flex-shrink: 0; }
+.so-past-hint {
+  margin: 4px 0 0;
+  font-size: 0.75rem;
+  color: var(--color-accent-warm, #d4a017);
+  font-style: italic;
+}
 
 .toggle-btn {
   background: var(--color-input-bg, #111113);
@@ -376,8 +465,8 @@ async function doDelete() {
   transition: all 0.15s;
 }
 .toggle-btn.active {
-  background: var(--color-primary, #6366f1);
-  border-color: var(--color-primary, #6366f1);
+  background: var(--color-primary);
+  border-color: var(--color-primary);
   color: #fff;
 }
 
@@ -403,7 +492,7 @@ async function doDelete() {
 }
 
 .btn-primary {
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: 8px;

frontend/src/components/InlineAssistPanel.vue

@@ -94,10 +94,10 @@ const markers: Record<DiffLine["type"], string> = {
 
 /* ── Streaming ── */
 .iap-streaming {
-  border-color: var(--color-primary, #6366f1);
+  border-color: var(--color-primary);
 }
 .iap-streaming .iap-header {
-  background: color-mix(in srgb, var(--color-primary, #6366f1) 8%, var(--color-bg-secondary));
+  background: color-mix(in srgb, var(--color-primary) 8%, var(--color-bg-secondary));
 }
 
 .iap-pulse {
@@ -105,7 +105,7 @@ const markers: Record<DiffLine["type"], string> = {
   width: 8px;
   height: 8px;
   border-radius: 50%;
-  background: var(--color-primary, #6366f1);
+  background: var(--color-primary);
   flex-shrink: 0;
   animation: iap-pulse 1.2s ease-in-out infinite;
 }
@@ -172,8 +172,8 @@ const markers: Record<DiffLine["type"], string> = {
   font-family: inherit;
 }
 .iap-btn-toggle:hover {
-  border-color: var(--color-primary, #6366f1);
-  color: var(--color-primary, #6366f1);
+  border-color: var(--color-primary);
+  color: var(--color-primary);
 }
 
 .iap-actions {

frontend/src/components/MarkdownToolbar.vue

@@ -78,6 +78,7 @@ const groups = [
           :class="['md-btn', { active: btn.isActive() }]"
           :title="btn.title"
           type="button"
+          tabindex="-1"
           @mousedown.prevent="btn.command()"
         >
           <span class="btn-icon" v-html="ICONS[btn.id]" />

frontend/src/components/NoteCard.vue

@@ -64,11 +64,11 @@ function goEdit() {
   text-decoration: none;
   color: inherit;
   background: var(--color-bg-card);
-  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.06), 0 0 0 1px rgba(99, 102, 241, 0.06);
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.06), 0 0 0 1px rgba(124, 58, 237, 0.06);
   transition: box-shadow 0.2s, transform 0.18s ease;
 }
 .note-card:hover {
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.10), 0 0 0 1px rgba(99, 102, 241, 0.14);
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.10), 0 0 0 1px rgba(124, 58, 237, 0.14);
   transform: translateY(-2px);
 }
 
@@ -89,7 +89,7 @@ function goEdit() {
 }
 .note-card.compact:hover {
   box-shadow: none;
-  background: rgba(99, 102, 241, 0.04);
+  background: rgba(124, 58, 237, 0.04);
   transform: none;
 }
 .note-title-compact {

frontend/src/components/ShareDialog.vue

@@ -337,7 +337,7 @@ onMounted(async () => {
 
 .btn-add-share {
   padding: 0.45rem 1rem;
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: 6px;

frontend/src/components/TagPill.vue

@@ -40,7 +40,7 @@ defineEmits<{
 }
 .tag-pill:hover {
   color: var(--color-primary);
-  background: rgba(99, 102, 241, 0.08);
+  background: var(--color-primary-tint);
 }
 .dismiss {
   background: none;

frontend/src/components/TaskCard.vue

@@ -112,11 +112,11 @@ function isOverdue(): boolean {
   text-decoration: none;
   color: inherit;
   background: var(--color-bg-card);
-  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.06), 0 0 0 1px rgba(99, 102, 241, 0.06);
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.06), 0 0 0 1px rgba(124, 58, 237, 0.06);
   transition: box-shadow 0.2s, transform 0.18s ease;
 }
 .task-card:hover {
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.10), 0 0 0 1px rgba(99, 102, 241, 0.14);
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.10), 0 0 0 1px rgba(124, 58, 237, 0.14);
   transform: translateY(-2px);
 }
 

frontend/src/components/ToolCallCard.vue

@@ -218,7 +218,7 @@ async function confirmDuplicate() {
   if (confirmState.value !== "idle") return;
   confirmState.value = "creating";
   const args = props.toolCall.arguments as Record<string, unknown>;
-  const isTask = props.toolCall.function === "create_task";
+  const isTask = !!(args.status);
   const endpoint = isTask ? "/api/tasks" : "/api/notes";
   const payload: Record<string, unknown> = {
     title: args.title,
@@ -751,7 +751,7 @@ function closeEventSlideOver(changed = false) {
   width: 8px;
   height: 8px;
   border-radius: 50%;
-  background: var(--color-primary, #6366f1);
+  background: var(--color-primary);
   flex-shrink: 0;
 }
 
@@ -773,14 +773,14 @@ function closeEventSlideOver(changed = false) {
 }
 .tool-event-card.clickable { cursor: pointer; }
 .tool-event-card.clickable:hover {
-  border-color: var(--color-primary, #6366f1);
-  background: color-mix(in srgb, var(--color-primary, #6366f1) 6%, var(--color-bg-card, #16161a));
+  border-color: var(--color-primary);
+  background: color-mix(in srgb, var(--color-primary) 6%, var(--color-bg-card, #16161a));
 }
 .tool-event-card-dot {
   width: 8px;
   height: 8px;
   border-radius: 50%;
-  background: var(--color-primary, #6366f1);
+  background: var(--color-primary);
   flex-shrink: 0;
   margin-top: 3px;
 }

frontend/src/components/WeatherCard.vue

@@ -9,6 +9,8 @@ interface ForecastDay {
   precip_probability: number | null
   precip_mm: number | null
   windspeed_max: number
+  precip_summary?: string
+  precip_peak_hour?: string
 }
 
 interface WeatherData {
@@ -21,6 +23,7 @@ interface WeatherData {
   yesterday_high: number | null
   yesterday_low: number | null
   wind_unit?: string
+  precip_summary?: string | null
   forecast: ForecastDay[]
 }
 
@@ -68,6 +71,11 @@ const fetchedAtLabel = computed(() => {
     return ''
   }
 })
+
+function hasPrecip(day: ForecastDay): boolean {
+  return (day.precip_probability != null && day.precip_probability > 0) ||
+         (day.precip_mm != null && day.precip_mm > 0)
+}
 </script>
 
 <template>
@@ -85,22 +93,39 @@ const fetchedAtLabel = computed(() => {
       Today: {{ weather.today_high }}° / {{ weather.today_low }}°
       <span v-if="tempDelta" class="weather-delta"> · {{ tempDelta }}</span>
     </div>
-    <div class="weather-forecast" v-if="weather.forecast.length">
-      <div v-for="day in weather.forecast" :key="day.day" class="weather-forecast-day">
-        <span class="forecast-day-name">{{ day.day }}</span>
-        <span class="forecast-icon">{{ weatherIcon(day.condition) }}</span>
-        <span class="forecast-condition">{{ day.condition }}</span>
-        <span class="forecast-temps">{{ day.high }}° / {{ day.low }}°</span>
-        <span v-if="day.precip_probability != null && day.precip_probability > 0" class="forecast-precip">
-          💧 {{ day.precip_probability }}%
-        </span>
-        <span v-else-if="day.precip_mm != null && day.precip_mm > 0" class="forecast-precip">
-          💧 {{ day.precip_mm.toFixed(1) }}mm
-        </span>
-        <span v-else class="forecast-precip forecast-precip--dry">💧 —</span>
-        <span class="forecast-wind">💨 {{ day.windspeed_max }} {{ weather.wind_unit ?? 'km/h' }}</span>
-      </div>
+    <div v-if="weather.precip_summary" class="weather-precip-summary">
+      💧 {{ weather.precip_summary }}
     </div>
+    <table class="weather-forecast" v-if="weather.forecast.length">
+      <thead>
+        <tr>
+          <th></th>
+          <th></th>
+          <th>Hi / Lo</th>
+          <th>💧</th>
+          <th>💨 {{ weather.wind_unit ?? 'km/h' }}</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr v-for="day in weather.forecast" :key="day.day">
+          <td class="forecast-day-name">{{ day.day }}</td>
+          <td class="forecast-icon">{{ weatherIcon(day.condition) }}</td>
+          <td class="forecast-temps">{{ day.high }}° / {{ day.low }}°</td>
+          <td class="forecast-precip" :class="{ 'forecast-precip--dry': !hasPrecip(day) }">
+            <template v-if="day.precip_summary">
+              <span class="precip-detail" :title="day.precip_summary">
+                {{ day.precip_probability }}%
+                <span v-if="day.precip_peak_hour" class="precip-peak">{{ day.precip_peak_hour }}</span>
+              </span>
+            </template>
+            <template v-else-if="day.precip_probability != null && day.precip_probability > 0">{{ day.precip_probability }}%</template>
+            <template v-else-if="day.precip_mm != null && day.precip_mm > 0">{{ day.precip_mm.toFixed(1) }}mm</template>
+            <template v-else>&mdash;</template>
+          </td>
+          <td class="forecast-wind">{{ day.windspeed_max }}</td>
+        </tr>
+      </tbody>
+    </table>
   </div>
   <div v-else class="weather-card weather-unavailable">
     Weather data unavailable — will retry at next slot.
@@ -115,6 +140,7 @@ const fetchedAtLabel = computed(() => {
   padding: 1rem 1.25rem;
   margin-bottom: 1rem;
   font-size: 0.9rem;
+  container-type: inline-size;
 }
 
 .weather-header {
@@ -142,12 +168,12 @@ const fetchedAtLabel = computed(() => {
 }
 
 .weather-icon {
-  font-size: 2rem;
+  font-size: clamp(1.5rem, 5cqi, 2.5rem);
   line-height: 1;
 }
 
 .weather-temp {
-  font-size: 2rem;
+  font-size: clamp(1.5rem, 5cqi, 2.5rem);
   font-weight: 700;
   line-height: 1;
 }
@@ -159,7 +185,7 @@ const fetchedAtLabel = computed(() => {
 
 .weather-today {
   color: var(--color-text-secondary);
-  margin-bottom: 0.75rem;
+  margin-bottom: 0.25rem;
   font-size: 0.85rem;
 }
 
@@ -168,48 +194,59 @@ const fetchedAtLabel = computed(() => {
   font-size: 0.82rem;
 }
 
-.weather-forecast {
-  display: flex;
-  gap: 0.75rem;
-  overflow-x: auto;
-  padding-top: 0.75rem;
-  border-top: 1px solid var(--color-border);
+.weather-precip-summary {
+  color: var(--color-text-secondary);
+  font-size: 0.83rem;
+  margin-bottom: 0.75rem;
+  padding: 0.35rem 0.5rem;
+  background: color-mix(in srgb, var(--color-primary) 8%, transparent);
+  border-radius: var(--radius-sm, 6px);
+  border-left: 2px solid color-mix(in srgb, var(--color-primary) 40%, transparent);
 }
 
-.weather-forecast-day {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.25rem;
-  min-width: 4.5rem;
+.weather-forecast {
+  width: 100%;
+  border-collapse: collapse;
+  margin-top: 0.75rem;
+  border-top: 1px solid var(--color-border);
   font-size: 0.8rem;
 }
 
+.weather-forecast thead th {
+  font-size: 0.68rem;
+  font-weight: 600;
+  color: var(--color-text-muted);
+  text-align: right;
+  padding: 0.5rem 0.4rem 0.25rem;
+  white-space: nowrap;
+}
+
+.weather-forecast thead th:first-child,
+.weather-forecast thead th:nth-child(2) {
+  text-align: left;
+}
+
+.weather-forecast tbody td {
+  padding: 0.3rem 0.4rem;
+  white-space: nowrap;
+  vertical-align: middle;
+}
+
 .forecast-day-name {
   font-weight: 600;
 }
 
 .forecast-icon {
-  font-size: 1.2rem;
+  font-size: clamp(0.9rem, 3cqi, 1.3rem);
   line-height: 1;
 }
 
-.forecast-condition {
-  font-size: 0.7rem;
-  color: var(--color-text-muted);
-  text-align: center;
-  line-height: 1.2;
-  word-break: break-word;
-}
-
 .forecast-temps {
-  white-space: nowrap;
+  text-align: right;
 }
 
-.forecast-precip,
-.forecast-wind {
-  font-size: 0.72rem;
-  white-space: nowrap;
+.forecast-precip {
+  text-align: right;
   color: var(--color-text-muted);
 }
 
@@ -217,6 +254,23 @@ const fetchedAtLabel = computed(() => {
   opacity: 0.35;
 }
 
+.precip-detail {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 0.3em;
+}
+
+.precip-peak {
+  font-size: 0.7rem;
+  color: var(--color-text-muted);
+  opacity: 0.8;
+}
+
+.forecast-wind {
+  text-align: right;
+  color: var(--color-text-muted);
+}
+
 .weather-unavailable {
   color: var(--color-text-muted);
   font-style: italic;

frontend/src/composables/useOnnxPreloader.ts

@@ -0,0 +1,43 @@
+import { ref, readonly } from 'vue'
+
+/**
+ * Idle-preload the Silero VAD ONNX model and its companion assets.
+ *
+ * `@ricky0123/vad-web` pulls ~2MB of ONNX model + ~5MB of onnxruntime-web
+ * WASM the first time `MicVAD.new()` runs. Calling `defaultModelFetcher`
+ * during page idle warms the browser cache so the first mic click feels
+ * instant. If the preload fails, VAD simply loads lazily on first click.
+ */
+const ready = ref(false)
+let loading = false
+
+export function useOnnxPreloader() {
+  async function preload() {
+    if (ready.value || loading) return
+    loading = true
+    try {
+      const { defaultModelFetcher } = await import('@ricky0123/vad-web')
+      // Asset lives at site root because vite-plugin-static-copy drops it
+      // there. Match whatever path MicVAD will use at call time (see useVad).
+      await defaultModelFetcher('/silero_vad_v5.onnx')
+      ready.value = true
+    } catch {
+      // Non-fatal — MicVAD will load the model itself on first use.
+    } finally {
+      loading = false
+    }
+  }
+
+  function schedulePreload() {
+    if (ready.value) return
+    if (typeof window === 'undefined') return
+    if ('requestIdleCallback' in window) {
+      (window as Window & { requestIdleCallback: (cb: () => void, opts: { timeout: number }) => void })
+        .requestIdleCallback(() => void preload(), { timeout: 5000 })
+    } else {
+      setTimeout(() => void preload(), 5000)
+    }
+  }
+
+  return { ready: readonly(ready), schedulePreload }
+}

frontend/src/composables/useSilenceDetector.ts

@@ -1,69 +0,0 @@
-import { ref, readonly } from 'vue'
-
-export interface SilenceDetectorOptions {
-  thresholdDb?: number       // default -40
-  silenceDurationMs?: number // default 1500
-  minRecordingMs?: number    // default 500
-}
-
-export function useSilenceDetector(options: SilenceDetectorOptions = {}) {
-  const {
-    thresholdDb = -40,
-    silenceDurationMs = 1500,
-    minRecordingMs = 500,
-  } = options
-
-  const amplitude = ref(0)
-  let audioCtx: AudioContext | null = null
-  let intervalId: ReturnType<typeof setInterval> | null = null
-  let silenceMs = 0
-  let startedAt = 0
-
-  function start(stream: MediaStream, onSilence: () => void): void {
-    stop()
-    audioCtx = new AudioContext()
-    // Some browsers start AudioContext in "suspended" state — resume so
-    // getByteFrequencyData returns real values instead of all zeros.
-    audioCtx.resume().catch(() => {})
-    const source = audioCtx.createMediaStreamSource(stream)
-    const analyser = audioCtx.createAnalyser()
-    analyser.fftSize = 256
-    source.connect(analyser)
-
-    const data = new Uint8Array(analyser.frequencyBinCount)
-    silenceMs = 0
-    startedAt = Date.now()
-
-    intervalId = setInterval(() => {
-      analyser.getByteFrequencyData(data)
-      const rms = Math.sqrt(data.reduce((s, v) => s + v * v, 0) / data.length) / 255
-      amplitude.value = rms
-
-      const db = rms > 0 ? 20 * Math.log10(rms) : -100
-      if (db < thresholdDb) {
-        silenceMs += 100
-        if (silenceMs >= silenceDurationMs && Date.now() - startedAt >= minRecordingMs) {
-          stop()
-          onSilence()
-        }
-      } else {
-        silenceMs = 0
-      }
-    }, 100)
-  }
-
-  function stop(): void {
-    if (intervalId !== null) {
-      clearInterval(intervalId)
-      intervalId = null
-    }
-    if (audioCtx) {
-      audioCtx.close().catch(() => {})
-      audioCtx = null
-    }
-    amplitude.value = 0
-    silenceMs = 0
-  }
-
-  return { amplitude: readonly(amplitude), start, stop }
-}

frontend/src/composables/useVad.ts

@@ -0,0 +1,154 @@
+import { ref, readonly } from 'vue'
+import type { MicVAD } from '@ricky0123/vad-web'
+
+export interface UseVadOptions {
+  onSpeechEnd: () => void
+  onNoSpeech: () => void
+  onVadError?: (message: string) => void
+  graceMs?: number
+  minRecordingMs?: number
+}
+
+/**
+ * Silero VAD-based speech detector.
+ *
+ * Replaces amplitude-based silence detection. Uses the Silero VAD v5 ONNX
+ * model via `@ricky0123/vad-web`. The package ships the model + audio
+ * worklet, and depends on `onnxruntime-web`'s WASM. Vite is configured
+ * (see `vite.config.ts`) to serve these assets from the site root, which
+ * is why we pass `baseAssetPath: "/"` and `onnxWASMBasePath: "/"`.
+ *
+ * `amplitude` is computed separately from a Web Audio API analyser node
+ * on the same stream — it drives the mic pulse animation and is not part
+ * of the stop decision. VAD's `onSpeechEnd` is the stop trigger.
+ *
+ * If VAD never detects speech during a session, calling `stopAndCheck()`
+ * fires `onNoSpeech` instead of treating the recording as transcribable.
+ */
+export function useVad(options: UseVadOptions) {
+  const {
+    onSpeechEnd,
+    onNoSpeech,
+    graceMs = 1500,
+    minRecordingMs = 500,
+  } = options
+
+  const speaking = ref(false)
+  const amplitude = ref(0)
+  const loaded = ref(false)
+
+  let micVad: MicVAD | null = null
+  let audioCtx: AudioContext | null = null
+  let analyserInterval: ReturnType<typeof setInterval> | null = null
+  let speechDetected = false
+  let speechStartedAt = 0
+  let recordingStartedAt = 0
+  let stopped = false
+
+  async function start(stream: MediaStream): Promise<void> {
+    await stop()
+    stopped = false
+    speechDetected = false
+    speechStartedAt = 0
+    recordingStartedAt = Date.now()
+
+    // Visual-only amplitude signal. This does NOT drive the stop decision.
+    audioCtx = new AudioContext()
+    await audioCtx.resume().catch(() => {})
+    const source = audioCtx.createMediaStreamSource(stream)
+    const analyser = audioCtx.createAnalyser()
+    analyser.fftSize = 1024
+    source.connect(analyser)
+    const samples = new Float32Array(analyser.fftSize)
+
+    analyserInterval = setInterval(() => {
+      analyser.getFloatTimeDomainData(samples)
+      let sumSq = 0
+      for (let i = 0; i < samples.length; i++) sumSq += samples[i] * samples[i]
+      const rms = Math.sqrt(sumSq / samples.length)
+      amplitude.value = Math.min(rms * 5, 1)
+    }, 100)
+
+    try {
+      const { MicVAD } = await import('@ricky0123/vad-web')
+      micVad = await MicVAD.new({
+        model: 'v5',
+        baseAssetPath: '/',
+        onnxWASMBasePath: '/',
+        // MicVAD manages its own audio graph, so we hand it the same stream
+        // the MediaRecorder is using. It won't consume or alter the stream.
+        getStream: async () => stream,
+        onSpeechStart: () => {
+          speaking.value = true
+          if (!speechDetected) {
+            speechDetected = true
+            speechStartedAt = Date.now()
+          }
+        },
+        onSpeechEnd: () => {
+          speaking.value = false
+          if (stopped) return
+          const now = Date.now()
+          const totalElapsed = now - recordingStartedAt
+          const sinceSpeechStart = speechStartedAt > 0 ? now - speechStartedAt : 0
+          if (totalElapsed >= minRecordingMs && sinceSpeechStart >= graceMs) {
+            stopped = true
+            onSpeechEnd()
+          }
+        },
+        onVADMisfire: () => {
+          // Speech-like blip that was too short to count. Reset the local flag
+          // so a true "no speech" session still hits onNoSpeech.
+          speaking.value = false
+        },
+      })
+      await micVad.start()
+      loaded.value = true
+    } catch (e) {
+      console.error('VAD init failed:', e)
+      options.onVadError?.(e instanceof Error ? e.message : String(e))
+    }
+  }
+
+  async function stop(): Promise<{ hadSpeech: boolean }> {
+    const had = speechDetected
+    stopped = true
+    speaking.value = false
+    amplitude.value = 0
+
+    if (analyserInterval !== null) {
+      clearInterval(analyserInterval)
+      analyserInterval = null
+    }
+    if (audioCtx) {
+      await audioCtx.close().catch(() => {})
+      audioCtx = null
+    }
+    if (micVad) {
+      try {
+        await micVad.pause()
+        await micVad.destroy()
+      } catch {
+        // Already destroyed or failed — nothing to clean up further.
+      }
+      micVad = null
+    }
+    return { hadSpeech: had }
+  }
+
+  async function stopAndCheck(): Promise<void> {
+    const { hadSpeech } = await stop()
+    if (!hadSpeech) {
+      onNoSpeech()
+    }
+  }
+
+  return {
+    speaking: readonly(speaking),
+    amplitude: readonly(amplitude),
+    loaded: readonly(loaded),
+    start,
+    stop,
+    stopAndCheck,
+  }
+}

frontend/src/stores/settings.ts

@@ -16,6 +16,10 @@ export const useSettingsStore = defineStore("settings", () => {
     () => settings.value.default_model || ""
   );
 
+  const rssEnabled = computed(
+    () => settings.value.rss_enabled === "true"
+  );
+
   // Voice status — checked once on login, refreshable from Settings
   const voiceEnabled = ref(false);
   const voiceSttReady = ref(false);
@@ -62,6 +66,7 @@ export const useSettingsStore = defineStore("settings", () => {
     loading,
     assistantName,
     defaultModel,
+    rssEnabled,
     voiceEnabled,
     voiceSttReady,
     voiceTtsReady,

frontend/src/views/BriefingView.vue

@@ -2,6 +2,7 @@
 import { ref, computed, onMounted, onUnmounted, watch, nextTick } from 'vue'
 import { useBackgroundRefresh } from '@/composables/useBackgroundRefresh'
 import { useChatStore } from '@/stores/chat'
+import { useSettingsStore } from '@/stores/settings'
 import ChatPanel from '@/components/ChatPanel.vue'
 import WeatherCard from '@/components/WeatherCard.vue'
 import BriefingSetupWizard from '@/components/BriefingSetupWizard.vue'
@@ -15,7 +16,9 @@ import {
   postRssReaction,
   deleteRssReaction,
   getNewsItems,
+  listEvents,
   type BriefingConversation,
+  type EventEntry,
 } from '@/api/client'
 import type { NewsItem } from '@/types/news'
 
@@ -33,6 +36,7 @@ interface WeatherData {
 }
 
 const chatStore = useChatStore()
+const settingsStore = useSettingsStore()
 
 // Setup wizard
 const showWizard = ref(false)
@@ -56,10 +60,32 @@ const todayConvId = ref<number | null>(null)
 
 const isToday = computed(() => selectedConvId.value === todayConvId.value)
 
-// Weather panel (left column)
+// Weather panel
 const weatherData = ref<WeatherData[]>([])
+const selectedWeatherIdx = ref(0)
 const tempUnit = ref<string>('C')
 
+interface CurrentConditions {
+  temperature: number | null;
+  windspeed: number | null;
+  description: string;
+  precip_next_3h: number[];
+  temp_unit: string;
+  location: string;
+}
+const currentConditions = ref<CurrentConditions | null>(null)
+let currentWeatherTimer: ReturnType<typeof setInterval> | null = null
+
+async function loadCurrentConditions() {
+  try {
+    currentConditions.value = await apiGet<CurrentConditions>('/api/briefing/weather/current')
+    // Patch the live temperature into the WeatherCard so it stays fresh
+    if (currentConditions.value?.temperature != null && weatherData.value.length > 0) {
+      weatherData.value[0] = { ...weatherData.value[0], current_temp: currentConditions.value.temperature }
+    }
+  } catch { /* silent — endpoint may not have locations configured */ }
+}
+
 async function loadWeather() {
   try {
     const data = await apiGet<{ locations: WeatherData[]; temp_unit: string }>('/api/briefing/weather')
@@ -68,6 +94,66 @@ async function loadWeather() {
   } catch { /* silent */ }
 }
 
+const refreshingWeather = ref(false)
+async function refreshWeather() {
+  refreshingWeather.value = true
+  try {
+    const data = await apiPost<{ locations: WeatherData[]; temp_unit: string }>('/api/briefing/weather/refresh', {})
+    weatherData.value = data.locations ?? []
+    tempUnit.value = data.temp_unit ?? 'C'
+  } catch { /* silent */ }
+  finally { refreshingWeather.value = false }
+}
+
+// Upcoming events (right column, below weather)
+const upcomingEvents = ref<EventEntry[]>([])
+
+interface GroupedDay {
+  label: string
+  dateKey: string
+  events: EventEntry[]
+}
+
+const groupedEvents = computed<GroupedDay[]>(() => {
+  const groups = new Map<string, EventEntry[]>()
+  const today = new Date()
+  today.setHours(0, 0, 0, 0)
+
+  for (const ev of upcomingEvents.value) {
+    const d = new Date(ev.start_dt)
+    const key = d.toISOString().slice(0, 10)
+    if (!groups.has(key)) groups.set(key, [])
+    groups.get(key)!.push(ev)
+  }
+
+  const result: GroupedDay[] = []
+  for (const [key, events] of groups) {
+    const d = new Date(key + 'T00:00:00')
+    const diff = Math.round((d.getTime() - today.getTime()) / 86_400_000)
+    let label: string
+    if (diff === 0) label = 'Today'
+    else if (diff === 1) label = 'Tomorrow'
+    else label = d.toLocaleDateString(undefined, { weekday: 'short', month: 'short', day: 'numeric' })
+    result.push({ label, dateKey: key, events })
+  }
+  return result
+})
+
+function formatEventTime(ev: EventEntry): string {
+  if (ev.all_day) return 'All day'
+  const d = new Date(ev.start_dt)
+  return d.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' })
+}
+
+async function loadEvents() {
+  try {
+    const now = new Date()
+    const end = new Date(now)
+    end.setDate(end.getDate() + 14)
+    upcomingEvents.value = await listEvents(now.toISOString(), end.toISOString())
+  } catch { /* silent */ }
+}
+
 // News panel (right column)
 const newsItems = ref<NewsItem[]>([])
 
@@ -90,6 +176,8 @@ async function loadAll() {
     getBriefingToday().catch(() => null),
     loadWeather(),
     loadNews(),
+    loadCurrentConditions(),
+    loadEvents(),
   ])
   conversations.value = convList
   if (today) {
@@ -198,11 +286,18 @@ useBackgroundRefresh(
 )
 
 let _mounted = true
-onUnmounted(() => { _mounted = false })
+onUnmounted(() => {
+  _mounted = false
+  if (currentWeatherTimer) clearInterval(currentWeatherTimer)
+})
 
 onMounted(async () => {
   await checkSetup()
-  if (!showWizard.value) await loadAll()
+  if (!showWizard.value) {
+    await loadAll()
+    // Poll current conditions every 30 minutes
+    currentWeatherTimer = setInterval(loadCurrentConditions, 30 * 60 * 1000)
+  }
 })
 </script>
 
@@ -232,21 +327,7 @@ onMounted(async () => {
         </div>
       </header>
 
-      <!-- Left column: Weather -->
-      <div class="briefing-left">
-        <div class="panel-label">Weather</div>
-        <template v-if="weatherData.length">
-          <WeatherCard
-            v-for="loc in weatherData"
-            :key="(loc as WeatherData).location"
-            :weather="loc"
-            :temp-unit="tempUnit"
-          />
-        </template>
-        <div v-else class="panel-empty">No weather configured</div>
-      </div>
-
-      <!-- Center column: Chat -->
+      <!-- Left column: Chat -->
       <div class="briefing-center">
         <ChatPanel
           variant="full"
@@ -257,8 +338,57 @@ onMounted(async () => {
         />
       </div>
 
-      <!-- Right column: News -->
+      <!-- Right column: Weather + News -->
       <div class="briefing-right">
+        <!-- Weather section (sticky) -->
+        <div class="weather-section" v-if="weatherData.length">
+          <div class="weather-section-header">
+            <div class="weather-tabs" v-if="weatherData.length > 1">
+              <button
+                v-for="(loc, i) in weatherData"
+                :key="(loc as WeatherData).location"
+                class="weather-tab"
+                :class="{ active: selectedWeatherIdx === i }"
+                @click="selectedWeatherIdx = i"
+              >{{ (loc as WeatherData).location }}</button>
+            </div>
+            <button
+              class="weather-refresh-btn"
+              :class="{ spinning: refreshingWeather }"
+              :disabled="refreshingWeather"
+              @click="refreshWeather"
+              title="Refresh weather"
+            >↻</button>
+          </div>
+          <WeatherCard
+            :weather="weatherData[selectedWeatherIdx]"
+            :temp-unit="tempUnit"
+          />
+        </div>
+
+        <!-- Upcoming events -->
+        <div class="events-section" v-if="groupedEvents.length">
+          <div class="panel-label-row">
+            <div class="panel-label">Upcoming</div>
+            <router-link to="/calendar" class="events-cal-link">Calendar →</router-link>
+          </div>
+          <div class="events-list">
+            <div v-for="group in groupedEvents" :key="group.dateKey" class="events-day-group">
+              <div class="events-day-label">{{ group.label }}</div>
+              <div v-for="ev in group.events" :key="ev.id" class="event-row">
+                <span class="event-dot" :style="ev.color ? { background: ev.color } : {}"></span>
+                <span class="event-body">
+                  <span class="event-title">{{ ev.title }}</span>
+                  <span class="event-time">{{ formatEventTime(ev) }}</span>
+                  <span v-if="ev.location" class="event-loc">{{ ev.location }}</span>
+                </span>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <!-- News section (scrollable) -->
+        <div v-if="settingsStore.rssEnabled" class="news-section">
         <div class="panel-label-row">
           <div class="panel-label">Today's News</div>
           <span v-if="newsItems.length" class="news-count">{{ newsItems.length }} items</span>
@@ -303,6 +433,7 @@ onMounted(async () => {
             >💬</button>
           </div>
         </div>
+        </div>
       </div>
     </div>
   </div>
@@ -318,7 +449,7 @@ onMounted(async () => {
 
 .briefing-shell {
   display: grid;
-  grid-template-columns: 1fr 2fr 1fr;
+  grid-template-columns: 1fr minmax(320px, 35%);
   grid-template-rows: auto 1fr;
   height: 100%;
   min-height: 0;
@@ -391,27 +522,10 @@ onMounted(async () => {
 }
 .btn-trigger:disabled { opacity: 0.5; cursor: not-allowed; }
 
-/* ─── Left column (Weather) ──────────────────────────────────────────────── */
-
-.briefing-left {
-  grid-column: 1;
-  grid-row: 2;
-  border-right: 1px solid var(--color-border);
-  overflow-y: auto;
-  padding: 1rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
-
-.briefing-left :deep(.weather-card) {
-  margin-bottom: 0;
-}
-
-/* ─── Center column (Chat) ───────────────────────────────────────────────── */
+/* ─── Left column (Chat) ─────────────────────────────────────────────────── */
 
 .briefing-center {
-  grid-column: 2;
+  grid-column: 1;
   grid-row: 2;
   display: flex;
   flex-direction: column;
@@ -423,14 +537,160 @@ onMounted(async () => {
   min-height: 0;
 }
 
-/* ─── Right column (News) ────────────────────────────────────────────────── */
+/* ─── Right column (Weather + News) ──────────────────────────────────────── */
 
 .briefing-right {
-  grid-column: 3;
+  grid-column: 2;
   grid-row: 2;
   border-left: 1px solid var(--color-border);
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+}
+
+.weather-section {
+  flex-shrink: 0;
+  padding: 1rem 1rem 0.5rem;
+}
+
+.weather-section :deep(.weather-card) {
+  margin-bottom: 0;
+}
+
+.weather-section-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 0.5rem;
+}
+
+.weather-refresh-btn {
+  background: none;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  color: var(--color-text-muted);
+  font-size: 1rem;
+  cursor: pointer;
+  padding: 0.2rem 0.45rem;
+  line-height: 1;
+  transition: all 0.15s;
+}
+.weather-refresh-btn:hover {
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+}
+.weather-refresh-btn:disabled { opacity: 0.5; cursor: not-allowed; }
+.weather-refresh-btn.spinning {
+  animation: spin 0.8s linear infinite;
+}
+@keyframes spin { to { transform: rotate(360deg); } }
+
+.weather-tabs {
+  display: flex;
+  gap: 0.25rem;
+}
+
+.weather-tab {
+  padding: 0.3rem 0.7rem;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: none;
+  color: var(--color-text-muted);
+  font-size: 0.78rem;
+  font-family: inherit;
+  cursor: pointer;
+  transition: all 0.15s;
+}
+
+.weather-tab:hover {
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+}
+
+.weather-tab.active {
+  background: color-mix(in srgb, var(--color-primary) 12%, transparent);
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+  font-weight: 600;
+}
+
+/* ─── Upcoming events ─────────────────────────────────────── */
+.events-section {
+  padding: 0.75rem 1rem;
+  border-top: 1px solid var(--color-border);
+}
+.events-cal-link {
+  font-size: 0.75rem;
+  color: var(--color-text-muted);
+  text-decoration: none;
+}
+.events-cal-link:hover { color: var(--color-primary); }
+.events-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.6rem;
+}
+.events-day-group {
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+}
+.events-day-label {
+  font-size: 0.72rem;
+  font-weight: 700;
+  color: var(--color-text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+  padding-bottom: 0.15rem;
+}
+.event-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.4rem;
+  padding: 0.25rem 0.4rem;
+  border-radius: 6px;
+}
+.event-row:hover {
+  background: color-mix(in srgb, var(--color-primary) 6%, transparent);
+}
+.event-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--color-primary);
+  flex-shrink: 0;
+  margin-top: 5px;
+}
+.event-body {
+  display: flex;
+  flex-direction: column;
+  gap: 0.05rem;
+  min-width: 0;
+}
+.event-title {
+  font-size: 0.82rem;
+  font-weight: 600;
+  color: var(--color-text);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.event-time {
+  font-size: 0.72rem;
+  color: var(--color-text-muted);
+}
+.event-loc {
+  font-size: 0.7rem;
+  color: var(--color-text-muted);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.news-section {
+  flex: 1;
   overflow-y: auto;
-  padding: 1rem;
+  padding: 0.75rem 1rem 1rem;
   display: flex;
   flex-direction: column;
   gap: 0.5rem;
@@ -457,6 +717,8 @@ onMounted(async () => {
   color: var(--color-text-muted);
 }
 
+/* ── Current conditions (live) ─────────────────────────── */
+
 .panel-empty {
   font-size: 0.82rem;
   color: var(--color-text-muted);
@@ -549,29 +811,18 @@ a.news-title:hover { text-decoration: underline; color: var(--color-primary); }
 @media (max-width: 900px) {
   .briefing-shell {
     grid-template-columns: 1fr;
-    grid-template-rows: auto auto 1fr auto;
-  }
-  .briefing-header {
-    grid-column: 1;
-    grid-row: 1;
-  }
-  .briefing-left {
-    grid-column: 1;
-    grid-row: 2;
-    border-right: none;
-    border-bottom: 1px solid var(--color-border);
-    max-height: 220px;
+    grid-template-rows: auto 1fr auto;
   }
   .briefing-center {
     grid-column: 1;
-    grid-row: 3;
+    grid-row: 2;
   }
   .briefing-right {
     grid-column: 1;
-    grid-row: 4;
+    grid-row: 3;
     border-left: none;
     border-top: 1px solid var(--color-border);
-    max-height: 260px;
+    max-height: 300px;
   }
 }
 </style>

frontend/src/views/CalendarView.vue

@@ -435,7 +435,7 @@ const upcomingGrouped = computed(() => {
 }
 
 .btn-new-event {
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: 8px;
@@ -482,8 +482,8 @@ const upcomingGrouped = computed(() => {
 }
 :deep(.fc-button:hover),
 :deep(.fc-button-active) {
-  background: var(--color-primary, #6366f1) !important;
-  border-color: var(--color-primary, #6366f1) !important;
+  background: var(--color-primary) !important;
+  border-color: var(--color-primary) !important;
   color: #fff !important;
 }
 :deep(.fc-button:focus) { box-shadow: none !important; }
@@ -494,7 +494,7 @@ const upcomingGrouped = computed(() => {
   font-size: 0.82rem;
 }
 :deep(.fc-daygrid-day.fc-day-today) {
-  background: rgba(99, 102, 241, 0.08);
+  background: var(--color-primary-tint);
 }
 :deep(.fc-event) {
   border-radius: 4px;
@@ -505,7 +505,7 @@ const upcomingGrouped = computed(() => {
 }
 :deep(.fc-event-main) { color: #fff; }
 :deep(.fc-event:not([style*="background"])) {
-  background: var(--color-primary, #6366f1);
+  background: var(--color-primary);
 }
 :deep(.fc-daygrid-day-frame) { min-height: 5rem; }
 :deep(.fc-scrollgrid) { border-color: var(--color-border, #2a2b30); }
@@ -574,8 +574,8 @@ const upcomingGrouped = computed(() => {
   background: rgba(255,255,255,0.08);
 }
 .picker-month.active {
-  background: rgba(99,102,241,0.22);
-  color: var(--color-primary, #818cf8);
+  background: rgba(124,58,237,0.22);
+  color: var(--color-primary);
   font-weight: 700;
 }
 
@@ -634,7 +634,7 @@ const upcomingGrouped = computed(() => {
 .upcoming-card-accent {
   width: 4px;
   flex-shrink: 0;
-  background: var(--ev-color, #6366f1);
+  background: var(--ev-color, #7c3aed);
 }
 
 .upcoming-card-body {
@@ -691,7 +691,7 @@ const upcomingGrouped = computed(() => {
 
 .popover-accent {
   height: 4px;
-  background: var(--color-primary, #6366f1);
+  background: var(--color-primary);
 }
 
 .popover-content {
@@ -750,7 +750,7 @@ const upcomingGrouped = computed(() => {
 }
 .popover-btn:hover { opacity: 0.85; }
 .popover-btn--edit {
-  background: var(--color-primary, #6366f1);
+  background: var(--color-primary);
   color: #fff;
 }
 .popover-btn--close {

frontend/src/views/ChatView.vue

@@ -2,6 +2,7 @@
 import { onMounted, onUnmounted, ref, computed, watch, nextTick } from "vue";
 import { useRoute, useRouter } from "vue-router";
 import { useChatStore } from "@/stores/chat";
+import { apiGet } from "@/api/client";
 import ChatPanel from "@/components/ChatPanel.vue";
 
 const route = useRoute();
@@ -10,6 +11,49 @@ const store = useChatStore();
 
 const summarizing = ref(false);
 const sidebarOpen = ref(false);
+const convSearchQuery = ref("");
+const headerKebabOpen = ref(false);
+const sidebarKebabOpen = ref(false);
+
+// ── RAG scope chip ────────────────────────────────────────────────────────────
+const projects = ref<{ id: number; title: string }[]>([]);
+const scopeDropdownOpen = ref(false);
+const scopePulse = ref(false);
+
+const scopeLabel = computed(() => {
+  const id = store.ragProjectId;
+  if (id === -1) return "All notes";
+  if (id === null) return "Orphan notes";
+  return projects.value.find((p) => p.id === id)?.title ?? `Project ${id}`;
+});
+
+async function loadProjects() {
+  try {
+    const data = await apiGet<{ projects: { id: number; title: string }[] }>(
+      "/api/projects?status=active"
+    );
+    projects.value = data.projects ?? [];
+  } catch {
+    projects.value = [];
+  }
+}
+
+async function onScopeSelect(value: number | null) {
+  scopeDropdownOpen.value = false;
+  const id = store.currentConversation?.id;
+  if (!id) return;
+  await store.updateRagScope(id, value);
+  scopePulse.value = true;
+  setTimeout(() => { scopePulse.value = false; }, 600);
+}
+
+watch(
+  () => store.ragProjectId,
+  () => {
+    scopePulse.value = true;
+    setTimeout(() => { scopePulse.value = false; }, 600);
+  }
+);
 
 let prevConvId: number | null = null;
 
@@ -46,7 +90,12 @@ const groupedConversations = computed((): ConvGroup[] => {
   const buckets: Record<string, typeof store.conversations> = {};
   const order: string[] = [];
 
-  for (const conv of store.conversations) {
+  const q = convSearchQuery.value.trim().toLowerCase();
+  const filtered = q
+    ? store.conversations.filter((c) => (c.title || "").toLowerCase().includes(q))
+    : store.conversations;
+
+  for (const conv of filtered) {
     const d = new Date(conv.updated_at);
     let key: string;
     if (d >= startOfToday) {
@@ -69,6 +118,8 @@ const groupedConversations = computed((): ConvGroup[] => {
 
 onMounted(async () => {
   document.addEventListener("keydown", onGlobalKeydown);
+  document.addEventListener("mousedown", onDocumentMousedown);
+  loadProjects();
   await store.fetchConversations();
   if (convId.value) {
     if (store.currentConversation?.id !== convId.value) {
@@ -187,36 +238,35 @@ async function handleSummarize() {
   }
 }
 
-// ── Research modal ────────────────────────────────────────────────────────────
-const showResearchModal = ref(false);
-const researchTopic = ref("");
 const chatPanelRef = ref<InstanceType<typeof ChatPanel> | null>(null);
 
-function toggleResearchModal() {
-  showResearchModal.value = !showResearchModal.value;
-  if (showResearchModal.value) {
-    researchTopic.value = "";
-    nextTick(() => {
-      const el = document.querySelector(".research-topic-input") as HTMLInputElement;
-      el?.focus();
-    });
-  }
+const contextCount = computed(() => chatPanelRef.value?.contextCount ?? 0);
+const contextSidebarOpen = computed(() => chatPanelRef.value?.sidebarOpen ?? false);
+function toggleContextSidebar() {
+  chatPanelRef.value?.toggleContextSidebar();
 }
 
-function submitResearch() {
-  const topic = researchTopic.value.trim();
-  if (!topic) return;
-  showResearchModal.value = false;
-  researchTopic.value = "";
-  // Prefill sends via ChatPanel — user sees it in the input, then it auto-submits
-  chatPanelRef.value?.send(`Research: ${topic}`);
+// ── Kebab dismissal ───────────────────────────────────────────────────────────
+function onDocumentMousedown(e: MouseEvent) {
+  const target = e.target as HTMLElement | null;
+  if (headerKebabOpen.value && !target?.closest(".header-kebab-wrapper")) {
+    headerKebabOpen.value = false;
+  }
+  if (sidebarKebabOpen.value && !target?.closest(".sidebar-kebab-wrapper")) {
+    sidebarKebabOpen.value = false;
+  }
+  if (scopeDropdownOpen.value && !target?.closest(".scope-chip-wrapper")) {
+    scopeDropdownOpen.value = false;
+  }
 }
 
 // ── Keyboard ──────────────────────────────────────────────────────────────────
 function onGlobalKeydown(e: KeyboardEvent) {
   if (e.key !== "Escape") return;
-  if (showResearchModal.value) {
-    showResearchModal.value = false;
+  if (headerKebabOpen.value || sidebarKebabOpen.value || scopeDropdownOpen.value) {
+    headerKebabOpen.value = false;
+    sidebarKebabOpen.value = false;
+    scopeDropdownOpen.value = false;
     return;
   }
   if (sidebarOpen.value) {
@@ -228,6 +278,7 @@ function onGlobalKeydown(e: KeyboardEvent) {
 
 onUnmounted(() => {
   document.removeEventListener("keydown", onGlobalKeydown);
+  document.removeEventListener("mousedown", onDocumentMousedown);
   if (prevConvId) {
     const conv = store.conversations.find((c) => c.id === prevConvId);
     if (conv && conv.message_count === 0) {
@@ -246,13 +297,35 @@ onUnmounted(() => {
     ></div>
     <aside class="chat-sidebar" :class="{ open: sidebarOpen }">
       <div class="sidebar-top-bar">
-        <button class="btn-new-conv" @click="newConversation">+ New Chat</button>
-        <button
-          class="btn-select-mode"
-          :class="{ active: selectMode }"
-          @click="toggleSelectMode"
-          title="Select conversations"
-        >Select</button>
+        <button class="btn-new-conv btn-new-conv--full" @click="newConversation">+ New Chat</button>
+        <div class="sidebar-search-row">
+          <input
+            v-model="convSearchQuery"
+            class="conv-search-input"
+            type="search"
+            placeholder="Search conversations…"
+            aria-label="Search conversations"
+          />
+          <div class="sidebar-kebab-wrapper">
+            <button
+              class="btn-kebab"
+              :class="{ active: sidebarKebabOpen }"
+              @click="sidebarKebabOpen = !sidebarKebabOpen"
+              aria-label="List actions"
+              title="List actions"
+            >
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor">
+                <circle cx="12" cy="5" r="1.75"/><circle cx="12" cy="12" r="1.75"/><circle cx="12" cy="19" r="1.75"/>
+              </svg>
+            </button>
+            <div v-if="sidebarKebabOpen" class="kebab-menu">
+              <button
+                class="kebab-item"
+                @click="sidebarKebabOpen = false; toggleSelectMode()"
+              >{{ selectMode ? "Exit select mode" : "Select conversations" }}</button>
+            </div>
+          </div>
+        </div>
       </div>
 
       <div v-if="selectMode" class="bulk-bar">
@@ -304,6 +377,10 @@ onUnmounted(() => {
         <p v-if="!store.conversations.length" class="empty-msg">
           No conversations yet
         </p>
+        <p
+          v-else-if="convSearchQuery && !groupedConversations.length"
+          class="empty-msg"
+        >No matches for “{{ convSearchQuery }}”</p>
       </div>
     </aside>
 
@@ -319,40 +396,68 @@ onUnmounted(() => {
           </button>
           <h2>{{ store.currentConversation.title || "New Chat" }}</h2>
 
-          <!-- Research modal trigger -->
-          <div class="research-wrapper">
+          <div class="scope-chip-wrapper">
             <button
-              class="btn-attach"
-              @click="toggleResearchModal"
-              :disabled="store.streaming || !store.chatReady"
-              title="Research a topic"
+              class="scope-chip"
+              :class="{ pulse: scopePulse }"
+              @click="scopeDropdownOpen = !scopeDropdownOpen"
+              title="Change RAG scope"
             >
-              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                <circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/>
-              </svg>
+              <span class="scope-dot">⊙</span> {{ scopeLabel }}
             </button>
-            <div v-if="showResearchModal" class="research-modal">
-              <div class="research-modal-header">Research topic</div>
-              <input
-                class="research-topic-input"
-                v-model="researchTopic"
-                placeholder="e.g. quantum computing"
-                @keydown.enter="submitResearch"
-                @keydown.escape="showResearchModal = false"
-              />
-              <div class="research-modal-actions">
-                <button class="btn-research-cancel" @click="showResearchModal = false">Cancel</button>
-                <button class="btn-research-go" @click="submitResearch" :disabled="!researchTopic.trim()">Go</button>
-              </div>
+            <div v-if="scopeDropdownOpen" class="scope-dropdown">
+              <button
+                class="scope-option"
+                :class="{ active: store.ragProjectId === null }"
+                @click="onScopeSelect(null)"
+              >Orphan notes only</button>
+              <button
+                v-for="p in projects"
+                :key="p.id"
+                class="scope-option"
+                :class="{ active: store.ragProjectId === p.id }"
+                @click="onScopeSelect(p.id)"
+              >{{ p.title }}</button>
+              <button
+                class="scope-option"
+                :class="{ active: store.ragProjectId === -1 }"
+                @click="onScopeSelect(-1)"
+              >All notes</button>
             </div>
           </div>
 
           <button
-            v-if="store.currentConversation.messages.length"
-            class="btn-summarize"
-            @click="handleSummarize"
-            :disabled="summarizing || store.streaming"
-          >{{ summarizing ? "Summarizing..." : "Summarize as Note" }}</button>
+            v-if="contextCount > 0"
+            class="btn-context-toggle"
+            :class="{ active: contextSidebarOpen }"
+            @click="toggleContextSidebar"
+            :title="contextSidebarOpen ? 'Hide context panel' : 'Show context panel'"
+          >
+            <span class="context-icon">📎</span>
+            <span class="context-label">Context</span>
+            <span class="context-count-badge">{{ contextCount }}</span>
+          </button>
+
+          <div class="header-kebab-wrapper">
+            <button
+              class="btn-kebab"
+              :class="{ active: headerKebabOpen }"
+              @click="headerKebabOpen = !headerKebabOpen"
+              aria-label="Conversation actions"
+              title="Conversation actions"
+            >
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor">
+                <circle cx="12" cy="5" r="1.75"/><circle cx="12" cy="12" r="1.75"/><circle cx="12" cy="19" r="1.75"/>
+              </svg>
+            </button>
+            <div v-if="headerKebabOpen" class="kebab-menu kebab-menu--right">
+              <button
+                class="kebab-item"
+                :disabled="!store.currentConversation.messages.length || summarizing || store.streaming"
+                @click="headerKebabOpen = false; handleSummarize()"
+              >{{ summarizing ? "Summarizing…" : "Summarize as Note" }}</button>
+            </div>
+          </div>
         </div>
 
         <ChatPanel
@@ -397,12 +502,12 @@ onUnmounted(() => {
 
 .sidebar-top-bar {
   display: flex;
+  flex-direction: column;
   gap: 0.5rem;
   padding: 0.75rem;
 }
 
 .btn-new-conv {
-  flex: 1;
   padding: 0.5rem;
   background: var(--color-primary);
   color: #fff;
@@ -412,23 +517,31 @@ onUnmounted(() => {
   font-size: 0.9rem;
   transition: box-shadow 0.15s, opacity 0.15s;
 }
+.btn-new-conv--full { width: 100%; }
 .btn-new-conv:hover {
   opacity: 0.9;
   box-shadow: 0 0 14px rgba(129, 140, 248, 0.35);
 }
 
-.btn-select-mode {
-  background: none;
+.sidebar-search-row {
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+}
+.conv-search-input {
+  flex: 1;
+  min-width: 0;
+  padding: 0.4rem 0.6rem;
   border: 1px solid var(--color-border);
   border-radius: var(--radius-sm);
-  color: var(--color-text-muted);
-  font-size: 0.82rem;
-  padding: 0.4rem 0.6rem;
-  cursor: pointer;
-  white-space: nowrap;
+  background: var(--color-bg);
+  color: var(--color-text);
+  font-size: 0.85rem;
+  outline: none;
+  font-family: inherit;
 }
-.btn-select-mode:hover,
-.btn-select-mode.active { border-color: var(--color-primary); color: var(--color-primary); }
+.conv-search-input:focus { border-color: var(--color-primary); }
+.conv-search-input::placeholder { color: var(--color-text-muted); }
 
 .bulk-bar {
   display: flex;
@@ -522,12 +635,12 @@ onUnmounted(() => {
   overflow: hidden;
 }
 
-/* ChatPanel fills the remaining space in chat-main */
+/* ChatPanel fills the remaining space in chat-main. Layout (grid vs
+ * flex) is owned by ChatPanel's own .chat-full root — don't force a
+ * display here or it overrides the grid. */
 .chat-panel-fill {
   flex: 1;
   min-height: 0;
-  display: flex;
-  flex-direction: column;
 }
 
 .chat-header {
@@ -548,87 +661,138 @@ onUnmounted(() => {
   min-width: 0;
 }
 
-.btn-summarize {
-  padding: 0.3rem 0.75rem;
-  background: var(--color-bg-secondary);
-  color: var(--color-text);
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-sm);
-  cursor: pointer;
-  font-size: 0.85rem;
-  white-space: nowrap;
-}
-.btn-summarize:hover:not(:disabled) {
-  background: var(--color-primary); color: #fff; border-color: var(--color-primary);
-}
-.btn-summarize:disabled { opacity: 0.6; cursor: default; }
-
-.btn-attach {
+/* Kebab button + dropdown menu — shared by header and sidebar */
+.btn-kebab {
   background: none;
   border: none;
   cursor: pointer;
   color: var(--color-text-muted);
-  opacity: 0.6;
-  padding: 0.2rem;
+  padding: 0.25rem;
   display: flex;
   align-items: center;
+  justify-content: center;
+  border-radius: var(--radius-sm);
+  flex-shrink: 0;
 }
-.btn-attach:hover { opacity: 1; }
-.btn-attach:disabled { opacity: 0.25; cursor: default; }
+.btn-kebab:hover { color: var(--color-text); background: var(--color-bg-secondary); }
+.btn-kebab.active { color: var(--color-primary); }
 
-.research-wrapper { position: relative; }
-.research-modal {
+.header-kebab-wrapper,
+.sidebar-kebab-wrapper {
+  position: relative;
+}
+
+/* RAG scope chip (header) */
+.scope-chip-wrapper { position: relative; flex-shrink: 0; }
+.scope-chip {
+  display: flex;
+  align-items: center;
+  gap: 0.3rem;
+  background: none;
+  border: 1px solid var(--color-border);
+  border-radius: 20px;
+  padding: 0.2rem 0.65rem;
+  font-size: 0.75rem;
+  color: var(--color-text-muted);
+  cursor: pointer;
+  transition: border-color 0.15s, color 0.15s;
+}
+.scope-chip:hover { border-color: var(--color-primary); color: var(--color-primary); }
+.scope-chip.pulse { animation: pulse-chip 0.6s ease; }
+@keyframes pulse-chip {
+  0%, 100% { border-color: var(--color-border); }
+  50% {
+    border-color: var(--color-primary);
+    color: var(--color-primary);
+    box-shadow: 0 0 6px rgba(99, 102, 241, 0.4);
+  }
+}
+.scope-dot { font-size: 0.6rem; }
+.scope-dropdown {
   position: absolute;
-  top: calc(100% + 8px);
+  top: calc(100% + 4px);
   right: 0;
+  min-width: 200px;
+  background: var(--color-bg-card);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  box-shadow: 0 4px 16px var(--color-shadow);
+  z-index: 20;
+  overflow: hidden;
+}
+.scope-option {
+  display: block;
+  width: 100%;
+  padding: 0.45rem 0.75rem;
+  text-align: left;
+  background: none;
+  border: none;
+  font-size: 0.85rem;
+  color: var(--color-text);
+  cursor: pointer;
+}
+.scope-option:hover { background: var(--color-bg-secondary); }
+.scope-option.active { color: var(--color-primary); font-weight: 600; }
+
+/* Context toggle button (header) */
+.btn-context-toggle {
+  display: flex;
+  align-items: center;
+  gap: 0.3rem;
+  background: none;
+  border: 1px solid var(--color-border);
+  border-radius: 20px;
+  padding: 0.2rem 0.55rem;
+  font-size: 0.75rem;
+  color: var(--color-text-muted);
+  cursor: pointer;
+  flex-shrink: 0;
+  transition: border-color 0.15s, color 0.15s, background 0.15s;
+  font-family: inherit;
+}
+.btn-context-toggle:hover { border-color: var(--color-primary); color: var(--color-primary); }
+.btn-context-toggle.active {
+  background: color-mix(in srgb, var(--color-primary) 10%, transparent);
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+}
+.context-icon { font-size: 0.85rem; line-height: 1; }
+.context-count-badge {
+  font-size: 0.65rem;
+  font-weight: 700;
+  background: var(--color-bg);
+  padding: 0.05rem 0.35rem;
+  border-radius: 8px;
+  color: var(--color-text);
+}
+
+.kebab-menu {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  min-width: 180px;
   background: var(--color-bg-card);
   border: 1px solid var(--color-border);
   border-radius: var(--radius-md);
   box-shadow: 0 4px 20px var(--color-shadow);
-  padding: 0.75rem;
-  min-width: 280px;
+  padding: 0.25rem;
   z-index: 20;
 }
-.research-modal-header {
-  font-size: 0.8rem;
-  font-weight: 600;
-  color: var(--color-text-muted);
-  margin-bottom: 0.5rem;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-}
-.research-topic-input {
+.kebab-menu--right { left: auto; right: 0; }
+.kebab-item {
+  display: block;
   width: 100%;
-  padding: 0.45rem 0.65rem;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-sm);
-  background: var(--color-bg);
+  text-align: left;
+  background: none;
+  border: none;
   color: var(--color-text);
-  font-size: 0.9rem;
-  outline: none;
-  font-family: inherit;
-  box-sizing: border-box;
+  font-size: 0.85rem;
+  padding: 0.45rem 0.65rem;
+  border-radius: var(--radius-sm);
+  cursor: pointer;
 }
-.research-topic-input:focus { border-color: var(--color-primary); }
-.research-modal-actions {
-  display: flex;
-  gap: 0.5rem;
-  margin-top: 0.5rem;
-  justify-content: flex-end;
-}
-.btn-research-cancel {
-  background: none; border: 1px solid var(--color-border);
-  border-radius: var(--radius-sm); padding: 0.3rem 0.65rem;
-  font-size: 0.85rem; cursor: pointer; color: var(--color-text-muted);
-}
-.btn-research-cancel:hover { border-color: var(--color-text-muted); }
-.btn-research-go {
-  background: var(--color-primary); color: #fff; border: none;
-  border-radius: var(--radius-sm); padding: 0.3rem 0.75rem;
-  font-size: 0.85rem; cursor: pointer; font-weight: 600;
-}
-.btn-research-go:disabled { opacity: 0.4; cursor: default; }
-.btn-research-go:not(:disabled):hover { opacity: 0.9; }
+.kebab-item:hover:not(:disabled) { background: var(--color-bg-secondary); color: var(--color-primary); }
+.kebab-item:disabled { opacity: 0.4; cursor: default; }
 
 .no-conversation {
   flex: 1;
@@ -639,6 +803,9 @@ onUnmounted(() => {
   gap: 1rem;
   color: var(--color-text-muted);
 }
+.no-conversation .btn-new-conv {
+  flex: none;
+}
 
 .empty-msg {
   color: var(--color-text-muted);

frontend/src/views/HomeView.vue

@@ -569,7 +569,7 @@ function formatUpcomingTime(event: EventEntry): string {
   border-radius: var(--radius-lg);
   padding: 1.25rem 1.5rem;
   margin-bottom: 1.75rem;
-  box-shadow: 0 2px 16px rgba(99, 102, 241, 0.08), 0 1px 4px rgba(0, 0, 0, 0.06);
+  box-shadow: 0 2px 16px rgba(124, 58, 237, 0.08), 0 1px 4px rgba(0, 0, 0, 0.06);
 }
 .hero-top {
   display: flex;
@@ -605,20 +605,20 @@ function formatUpcomingTime(event: EventEntry): string {
   align-items: center;
   gap: 0.4rem;
   padding: 0.55rem 1.1rem;
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border-radius: var(--radius-sm);
   text-decoration: none;
   font-size: 0.9rem;
   font-weight: 600;
   white-space: nowrap;
-  box-shadow: 0 1px 6px rgba(99, 102, 241, 0.3);
+  box-shadow: 0 1px 6px rgba(124, 58, 237, 0.3);
   transition: opacity 0.15s, box-shadow 0.15s;
   flex-shrink: 0;
 }
 .btn-workspace-hero:hover {
   opacity: 0.9;
-  box-shadow: 0 3px 14px rgba(99, 102, 241, 0.45);
+  box-shadow: 0 3px 14px rgba(124, 58, 237, 0.45);
 }
 
 .hero-milestones { margin-bottom: 0.75rem; }
@@ -760,8 +760,8 @@ function formatUpcomingTime(event: EventEntry): string {
   font-weight: 500;
 }
 .urgency-in-progress {
-  background: color-mix(in srgb, #6366f1 15%, transparent);
-  color: #6366f1;
+  background: color-mix(in srgb, #7c3aed 15%, transparent);
+  color: #7c3aed;
 }
 .urgency-todo {
   background: color-mix(in srgb, var(--color-text-muted) 12%, transparent);
@@ -892,14 +892,14 @@ function formatUpcomingTime(event: EventEntry): string {
   width: 100%;
 }
 .upcoming-event-card:hover {
-  border-color: var(--color-primary, #6366f1);
-  background: color-mix(in srgb, var(--color-primary, #6366f1) 6%, var(--color-bg-card));
+  border-color: var(--color-primary);
+  background: color-mix(in srgb, var(--color-primary) 6%, var(--color-bg-card));
 }
 .upcoming-event-dot {
   width: 8px;
   height: 8px;
   border-radius: 50%;
-  background: var(--color-primary, #6366f1);
+  background: var(--color-primary);
   flex-shrink: 0;
   margin-top: 4px;
 }

frontend/src/views/KnowledgeView.vue

@@ -27,8 +27,12 @@ interface KnowledgeItem {
   relationship?: string;
   email?: string;
   phone?: string;
+  birthday?: string;
+  organization?: string;
   address?: string;
   hours?: string;
+  website?: string;
+  category?: string;
   item_count?: number;
   checked_count?: number;
   list_items?: { text: string; checked: boolean }[];
@@ -243,7 +247,7 @@ const chatCollapsed = ref(false);
 const chatConvId = ref<number | null>(null);
 async function onMinichatSubmit(payload: { content: string; contextNoteId?: number }) {
   if (!chatConvId.value) {
-    const conv = await chatStore.createConversation("Knowledge chat");
+    const conv = await chatStore.createConversation();
     chatConvId.value = conv.id;
     await chatStore.fetchConversation(conv.id);
   } else if (chatStore.currentConversation?.id !== chatConvId.value) {
@@ -251,7 +255,7 @@ async function onMinichatSubmit(payload: { content: string; contextNoteId?: numb
   }
   chatOpen.value = true;
   chatCollapsed.value = false;
-  await chatStore.sendMessage(payload.content, payload.contextNoteId, undefined, true);
+  await chatStore.sendMessage(payload.content, payload.contextNoteId, undefined, false);
 }
 
 // ─── Auto-refresh cards when chat creates/edits notes or tasks ───────────────
@@ -418,12 +422,30 @@ onUnmounted(() => {
       <aside class="filter-panel">
         <!-- New note button -->
         <div class="new-note-wrap">
-          <button class="btn-new-note" @click="newNoteMenuOpen ? createNew('note') : (newNoteMenuOpen = true)">+ New note</button>
+          <button class="btn-new-note" @click="newNoteMenuOpen = !newNoteMenuOpen">
+            <span class="btn-new-icon">+</span> New
+          </button>
           <div v-if="newNoteMenuOpen" class="new-note-menu">
-            <button @click="createNew('task')">Task</button>
-            <button @click="createNew('person')">Person</button>
-            <button @click="createNew('place')">Place</button>
-            <button @click="createNew('list')">List</button>
+            <button @click="createNew('note')">
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/></svg>
+              Note
+            </button>
+            <button @click="createNew('task')">
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M9 11l3 3L22 4"/><path d="M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"/></svg>
+              Task
+            </button>
+            <button @click="createNew('person')">
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg>
+              Person
+            </button>
+            <button @click="createNew('place')">
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z"/><circle cx="12" cy="10" r="3"/></svg>
+              Place
+            </button>
+            <button @click="createNew('list')">
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/></svg>
+              List
+            </button>
           </div>
         </div>
 
@@ -517,6 +539,7 @@ onUnmounted(() => {
               <span v-if="item.note_type === 'note'">Note</span>
               <span v-else-if="item.note_type === 'person'">Person</span>
               <span v-else-if="item.note_type === 'place'">Place</span>
+              <span v-else-if="item.note_type === 'task'">Task</span>
               <span v-else>List</span>
             </span>
 
@@ -526,11 +549,13 @@ onUnmounted(() => {
               <!-- Person specifics -->
               <div v-if="item.note_type === 'person'" class="k-card-meta">
                 <span v-if="item.relationship" class="meta-chip">{{ item.relationship }}</span>
+                <span v-if="item.organization" class="meta-muted">{{ item.organization }}</span>
                 <span v-if="item.phone" class="meta-muted">{{ item.phone }}</span>
               </div>
 
               <!-- Place specifics -->
               <div v-else-if="item.note_type === 'place'" class="k-card-meta">
+                <span v-if="item.category" class="meta-chip">{{ item.category }}</span>
                 <span v-if="item.address" class="meta-muted">{{ item.address }}</span>
                 <span v-if="item.hours" class="meta-muted">{{ item.hours }}</span>
               </div>
@@ -721,7 +746,7 @@ onUnmounted(() => {
   font-size: 0.78rem;
 }
 .today-link {
-  color: var(--color-primary, #7c3aed);
+  color: var(--color-primary);
   text-decoration: none;
   font-weight: 500;
   opacity: 0.85;
@@ -765,51 +790,71 @@ onUnmounted(() => {
   margin-bottom: 6px;
   padding: 0 4px;
 }
-/* ── New note button ─────────────────────────────────────── */
+/* ── New item button ─────────────────────────────────────── */
 .new-note-wrap {
   position: relative;
-  display: flex;
   margin-bottom: 16px;
 }
 .btn-new-note {
-  flex: 1;
-  padding: 7px 10px;
-  border-radius: 8px;
-  border: 1px solid rgba(124, 58, 237, 0.4);
-  background: rgba(124, 58, 237, 0.12);
-  color: var(--color-primary, #a78bfa);
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 8px 12px;
+  border-radius: 10px;
+  border: none;
+  background: var(--gradient-cta);
+  color: #fff;
   cursor: pointer;
   font-size: 0.85rem;
-  font-weight: 500;
-  text-align: left;
-  transition: background 0.15s;
+  font-weight: 600;
+  transition: box-shadow 0.15s;
+}
+.btn-new-note:hover { box-shadow: var(--glow-cta-hover); }
+.btn-new-icon {
+  font-size: 1.1rem;
+  line-height: 1;
+  font-weight: 300;
 }
-.btn-new-note:hover { background: rgba(124, 58, 237, 0.2); box-shadow: 0 0 12px rgba(124, 58, 237, 0.25); }
 .new-note-menu {
   position: absolute;
-  top: calc(100% + 4px);
+  top: calc(100% + 6px);
   left: 0;
   right: 0;
-  background: var(--color-bg-tertiary, #1a1b1e);
-  border: 1px solid rgba(124, 58, 237, 0.3);
-  border-radius: 8px;
+  background: var(--color-bg-card);
+  border: 1px solid var(--color-border);
+  border-radius: 10px;
   overflow: hidden;
   z-index: 50;
-  box-shadow: 0 4px 20px rgba(0,0,0,0.4);
+  box-shadow: 0 8px 28px rgba(0, 0, 0, 0.45);
+  padding: 4px 0;
 }
 .new-note-menu button {
-  display: block;
+  display: flex;
+  align-items: center;
+  gap: 10px;
   width: 100%;
-  padding: 7px 12px;
+  padding: 9px 14px;
   background: none;
   border: none;
   color: var(--color-text);
   cursor: pointer;
   font-size: 0.84rem;
   text-align: left;
-  transition: background 0.12s;
+  transition: background 0.12s, color 0.12s;
+}
+.new-note-menu button:hover {
+  background: var(--color-primary-tint);
+  color: var(--color-primary);
+}
+.new-note-menu button svg {
+  flex-shrink: 0;
+  opacity: 0.6;
+}
+.new-note-menu button:hover svg {
+  opacity: 1;
+  stroke: var(--color-primary);
 }
-.new-note-menu button:hover { background: rgba(124, 58, 237, 0.12); }
 
 .filter-btn {
   display: flex;
@@ -830,8 +875,8 @@ onUnmounted(() => {
 }
 .filter-btn:hover { background: rgba(255,255,255,0.05); opacity: 1; }
 .filter-btn.active {
-  background: rgba(124, 58, 237, 0.15);
-  color: var(--color-primary, #a78bfa);
+  background: var(--color-primary-wash);
+  color: var(--color-primary);
   opacity: 1;
 }
 .filter-btn-label { flex: 1; }
@@ -848,7 +893,7 @@ onUnmounted(() => {
 }
 .filter-btn.active .filter-count {
   background: rgba(124, 58, 237, 0.2);
-  color: var(--color-primary, #a78bfa);
+  color: var(--color-primary);
 }
 .filter-tag { font-size: 0.78rem; }
 
@@ -893,7 +938,7 @@ onUnmounted(() => {
   outline: none;
   transition: border-color 0.15s;
 }
-.search-input:focus { border-color: var(--color-primary, #7c3aed); }
+.search-input:focus { border-color: var(--color-primary); }
 .sort-select {
   padding: 7px 10px;
   border-radius: 8px;
@@ -920,9 +965,9 @@ onUnmounted(() => {
 }
 .btn-graph:hover { color: var(--color-text); border-color: rgba(255,255,255,0.2); }
 .btn-graph.active {
-  background: rgba(124, 58, 237, 0.15);
+  background: var(--color-primary-wash);
   border-color: rgba(124, 58, 237, 0.35);
-  color: var(--color-primary, #a78bfa);
+  color: var(--color-primary);
 }
 
 /* ── Card grid ───────────────────────────────────────────── */
@@ -954,16 +999,16 @@ onUnmounted(() => {
 }
 .k-card:hover {
   transform: translateY(-2px);
-  box-shadow: 0 8px 24px rgba(124, 58, 237, 0.15), 0 2px 8px rgba(0, 0, 0, 0.3);
-  border-color: rgba(124, 58, 237, 0.2);
+  box-shadow: 0 8px 28px rgba(124, 58, 237, 0.25), 0 2px 8px rgba(0, 0, 0, 0.3);
+  border-color: rgba(124, 58, 237, 0.35);
 }
 
 /* Type-specific card DNA */
-.k-card--note   { border-color: rgba(124, 58, 237, 0.12); }
-.k-card--task   { border-color: rgba(212, 160, 23, 0.10); }
-.k-card--person { border-color: rgba(16, 185, 129, 0.10); }
-.k-card--place  { border-color: rgba(245, 158, 11, 0.10); }
-.k-card--list   { border-color: rgba(56, 189, 248, 0.10); }
+.k-card--note   { border-color: rgba(124, 58, 237, 0.20); }
+.k-card--task   { border-color: rgba(212, 160, 23, 0.18); }
+.k-card--person { border-color: rgba(16, 185, 129, 0.18); }
+.k-card--place  { border-color: rgba(245, 158, 11, 0.18); }
+.k-card--list   { border-color: rgba(56, 189, 248, 0.18); }
 
 /* Top gradient bars */
 .k-card--note::before,
@@ -981,8 +1026,8 @@ onUnmounted(() => {
   background: linear-gradient(90deg, #7c3aed, #a78bfa);
 }
 .k-card--task::before {
-  width: 50%;
-  background: linear-gradient(90deg, #d4a017, transparent);
+  right: 0;
+  background: linear-gradient(90deg, #d4a017, #fbbf24);
 }
 .k-card--list::before {
   right: 0;
@@ -1020,7 +1065,7 @@ onUnmounted(() => {
 .badge--person { background: rgba(16,185,129,0.15); color: #34d399; }
 .badge--place  { background: rgba(245,158,11,0.15); color: #fbbf24; }
 .badge--list   { background: rgba(56,189,248,0.15); color: #7dd3fc; }
-.badge--task   { background: rgba(167,139,250,0.15); color: #a78bfa; }
+.badge--task   { background: rgba(212,160,23,0.15); color: #fbbf24; }
 
 .k-card-body { flex: 1; padding-right: 40px; }
 .k-card-title {

frontend/src/views/NoteEditorView.vue

@@ -38,6 +38,81 @@ const dirty = ref(false);
 const saving = ref(false);
 const showPreview = ref(false);
 const sidebarOpen = ref(true);
+const notesExpanded = ref(false);
+
+// ── List builder ─────────────────────────────────────────────────────────────
+interface ListItem {
+  text: string;
+  checked: boolean;
+}
+const listItems = ref<ListItem[]>([]);
+const listItemRefs = ref<(HTMLInputElement | null)[]>([]);
+
+function parseListFromBody(bodyText: string): { items: ListItem[]; extra: string } {
+  const lines = bodyText.split('\n');
+  const items: ListItem[] = [];
+  const extraLines: string[] = [];
+  let pastList = false;
+  for (const line of lines) {
+    const stripped = line.trimStart();
+    if (!pastList && (stripped.startsWith('- [ ] ') || stripped.startsWith('- [x] ') || stripped.startsWith('- [X] '))) {
+      items.push({ text: stripped.slice(6), checked: !stripped.startsWith('- [ ] ') });
+    } else if (!pastList && stripped === '' && items.length > 0) {
+      pastList = true;
+    } else {
+      pastList = true;
+      extraLines.push(line);
+    }
+  }
+  return { items, extra: extraLines.join('\n').trim() };
+}
+
+function serializeListToBody(): string {
+  const listPart = listItems.value
+    .map(item => `- [${item.checked ? 'x' : ' '}] ${item.text}`)
+    .join('\n');
+  const extraPart = body.value.trim();
+  return extraPart ? `${listPart}\n\n${extraPart}` : listPart;
+}
+
+function addListItem(afterIndex?: number) {
+  const idx = afterIndex !== undefined ? afterIndex + 1 : listItems.value.length;
+  listItems.value.splice(idx, 0, { text: '', checked: false });
+  markDirty();
+  nextTick(() => {
+    listItemRefs.value[idx]?.focus();
+  });
+}
+
+function removeListItem(index: number) {
+  if (listItems.value.length <= 1) return;
+  listItems.value.splice(index, 1);
+  markDirty();
+  nextTick(() => {
+    const focusIdx = Math.max(0, index - 1);
+    listItemRefs.value[focusIdx]?.focus();
+  });
+}
+
+function onListItemKeydown(e: KeyboardEvent, index: number) {
+  if (e.key === 'Enter') {
+    e.preventDefault();
+    addListItem(index);
+  } else if (e.key === 'Backspace' && listItems.value[index].text === '') {
+    e.preventDefault();
+    removeListItem(index);
+  }
+}
+
+function onListItemInput(_index: number) {
+  markDirty();
+}
+
+function toggleListItemCheck(index: number) {
+  listItems.value[index].checked = !listItems.value[index].checked;
+  markDirty();
+}
+
 const editorRef = ref<InstanceType<typeof TiptapEditor> | null>(null);
 const titleRef = ref<HTMLInputElement | null>(null);
 const tiptapEditor = computed<Editor | null>(() => {
@@ -49,6 +124,15 @@ const noteId = computed(() =>
 );
 const isEditing = computed(() => noteId.value !== null);
 
+const titlePlaceholder = computed(() => {
+  switch (noteType.value) {
+    case 'person': return 'Name';
+    case 'place': return 'Place name';
+    case 'list': return 'List title';
+    default: return 'Title';
+  }
+});
+
 const renderedPreview = computed(() => renderMarkdown(body.value));
 
 // AI Assist — pass noteId for draft persistence
@@ -219,6 +303,13 @@ onMounted(async () => {
       milestoneId.value = store.currentNote.milestone_id ?? null;
       noteType.value = (store.currentNote.note_type as NoteType) || "note";
       Object.assign(entityMeta, store.currentNote.metadata || {});
+      notesExpanded.value = !!(store.currentNote.body || '').trim();
+      if (noteType.value === 'list') {
+        const parsed = parseListFromBody(body.value);
+        listItems.value = parsed.items.length > 0 ? parsed.items : [{ text: '', checked: false }];
+        body.value = parsed.extra;
+        notesExpanded.value = !!parsed.extra;
+      }
       savedTitle = title.value;
       savedBody = body.value;
       savedTags = [...tags.value];
@@ -233,6 +324,9 @@ onMounted(async () => {
     if (qt && ["note", "person", "place", "list"].includes(qt)) {
       noteType.value = qt as NoteType;
     }
+    if (noteType.value === 'list') {
+      listItems.value = [{ text: '', checked: false }];
+    }
   }
 
   // Restore pending draft if any
@@ -243,6 +337,9 @@ onMounted(async () => {
     // No draft — normal
   }
 
+  await nextTick();
+  titleRef.value?.focus();
+
   // Initial link suggestions
   fetchLinkSuggestions();
 });
@@ -250,11 +347,12 @@ onMounted(async () => {
 async function save() {
   if (saving.value) return;
   saving.value = true;
+  const finalBody = noteType.value === 'list' ? serializeListToBody() : body.value;
   try {
     if (isEditing.value) {
       await store.updateNote(noteId.value!, {
         title: title.value,
-        body: body.value,
+        body: finalBody,
         tags: tags.value,
         project_id: projectId.value,
         milestone_id: milestoneId.value,
@@ -273,7 +371,7 @@ async function save() {
     } else {
       const note = await store.createNote({
         title: title.value,
-        body: body.value,
+        body: finalBody,
         tags: tags.value,
         project_id: projectId.value,
         milestone_id: milestoneId.value,
@@ -304,7 +402,7 @@ async function confirmDelete() {
     await store.deleteNote(noteId.value);
     dirty.value = false;
     toast.show("Note deleted");
-    router.push("/notes");
+    router.push(projectId.value ? `/projects/${projectId.value}` : "/");
   } catch {
     toast.show("Failed to delete note", "error");
   }
@@ -314,9 +412,10 @@ async function confirmDelete() {
 async function doAutoSave() {
   if (!isEditing.value || saving.value) return;
   saving.value = true;
+  const finalBody = noteType.value === 'list' ? serializeListToBody() : body.value;
   try {
     await store.updateNote(noteId.value!, {
-      title: title.value, body: body.value, tags: tags.value,
+      title: title.value, body: finalBody, tags: tags.value,
       project_id: projectId.value, milestone_id: milestoneId.value,
       note_type: noteType.value, metadata: { ...entityMeta },
     });
@@ -346,7 +445,7 @@ onUnmounted(() => assist.clearSelection());
   <main class="editor-page note-editor-page">
     <div class="editor-header">
       <div class="toolbar">
-        <router-link to="/notes" class="btn-back">← Notes</router-link>
+        <router-link :to="projectId ? `/projects/${projectId}` : '/'" class="btn-back">← {{ projectId ? 'Project' : 'Knowledge' }}</router-link>
         <button class="btn-save" @click="save" :disabled="saving">
           {{ saving ? "Saving..." : "Save" }}
         </button>
@@ -357,7 +456,7 @@ onUnmounted(() => assist.clearSelection());
         ref="titleRef"
         v-model="title"
         type="text"
-        placeholder="Title"
+        :placeholder="titlePlaceholder"
         class="title-input"
         @input="markDirty"
         @keydown.ctrl.s.prevent="save"
@@ -370,48 +469,181 @@ onUnmounted(() => assist.clearSelection());
 
       <!-- ── Main column ────────────────────────────────────────── -->
       <div class="note-main" @keydown.ctrl.e.prevent="tiptapEditor?.commands.focus()">
-        <div class="body-tabs-row">
-          <div class="editor-tabs">
-            <button :class="['tab', { active: !showPreview }]" @click="showPreview = false">Write</button>
-            <button :class="['tab', { active: showPreview }]" @click="showPreview = true">Preview</button>
+        <!-- ── Person form ──────────────────────────────────────── -->
+        <template v-if="noteType === 'person'">
+          <div class="entity-form">
+            <div class="ef-field">
+              <label class="ef-label">Relationship</label>
+              <input class="ef-input" v-model="entityMeta.relationship" placeholder="e.g. Friend, Colleague, Family" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Birthday</label>
+              <input class="ef-input" type="date" v-model="entityMeta.birthday" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Email</label>
+              <input class="ef-input" type="email" v-model="entityMeta.email" placeholder="email@example.com" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Phone</label>
+              <input class="ef-input" type="tel" v-model="entityMeta.phone" placeholder="+1 555 000 0000" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Organization</label>
+              <input class="ef-input" v-model="entityMeta.organization" placeholder="Company or organization" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Address</label>
+              <input class="ef-input" v-model="entityMeta.address" placeholder="Street, City, State" @input="markDirty" />
+            </div>
           </div>
-          <MarkdownToolbar v-show="!showPreview && assist.state.value === 'idle'" :editor="tiptapEditor" />
-        </div>
-
-        <!-- Streaming preview -->
-        <template v-if="assist.state.value === 'streaming'">
-          <div class="stream-label">Generating...</div>
-          <div class="stream-preview prose" v-html="renderMarkdown(assist.streamingText.value)" />
-        </template>
-
-        <!-- Review: full-document diff -->
-        <template v-else-if="assist.state.value === 'review'">
-          <DiffView :diff="assist.diff.value" class="main-diff" />
-        </template>
-
-        <!-- Normal editor -->
-        <template v-else>
-          <Transition name="tab-fade" mode="out-in">
-            <div v-if="!showPreview" class="body-editor-wrap">
+          <div class="notes-section">
+            <button class="notes-toggle" @click="notesExpanded = !notesExpanded">
+              {{ notesExpanded ? '▾' : '▸' }} Notes
+            </button>
+            <div v-if="notesExpanded" class="notes-editor-wrap">
+              <MarkdownToolbar v-show="!showPreview" :editor="tiptapEditor" />
               <TiptapEditor
                 ref="editorRef"
                 :modelValue="body"
-                placeholder="Write your note in Markdown..."
+                placeholder="Additional notes, wikilinks, context..."
                 @update:modelValue="onBodyUpdate"
-                @selectionChange="onSelectionChange"
                 @escape="titleRef?.focus()"
               />
             </div>
-            <div
-              v-else
-              class="preview-pane prose"
-              v-html="renderedPreview"
-            />
-          </Transition>
+          </div>
         </template>
 
-        <!-- Error from assist -->
-        <div v-if="assist.error.value" class="assist-error">{{ assist.error.value }}</div>
+        <!-- ── Place form ───────────────────────────────────────── -->
+        <template v-else-if="noteType === 'place'">
+          <div class="entity-form">
+            <div class="ef-field">
+              <label class="ef-label">Address</label>
+              <input class="ef-input" v-model="entityMeta.address" placeholder="Street, City, State" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Phone</label>
+              <input class="ef-input" type="tel" v-model="entityMeta.phone" placeholder="+1 555 000 0000" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Hours</label>
+              <input class="ef-input" v-model="entityMeta.hours" placeholder="e.g. Mon–Fri 9am–5pm" @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Website</label>
+              <input class="ef-input" type="url" v-model="entityMeta.website" placeholder="https://..." @input="markDirty" />
+            </div>
+            <div class="ef-field">
+              <label class="ef-label">Category</label>
+              <input class="ef-input" v-model="entityMeta.category" placeholder="e.g. Restaurant, Office, Doctor" @input="markDirty" />
+            </div>
+          </div>
+          <div class="notes-section">
+            <button class="notes-toggle" @click="notesExpanded = !notesExpanded">
+              {{ notesExpanded ? '▾' : '▸' }} Notes
+            </button>
+            <div v-if="notesExpanded" class="notes-editor-wrap">
+              <MarkdownToolbar v-show="!showPreview" :editor="tiptapEditor" />
+              <TiptapEditor
+                ref="editorRef"
+                :modelValue="body"
+                placeholder="Additional notes, wikilinks, context..."
+                @update:modelValue="onBodyUpdate"
+                @escape="titleRef?.focus()"
+              />
+            </div>
+          </div>
+        </template>
+
+        <!-- ── List builder ─────────────────────────────────────── -->
+        <template v-else-if="noteType === 'list'">
+          <div class="list-builder">
+            <div
+              v-for="(item, idx) in listItems"
+              :key="idx"
+              class="lb-item"
+            >
+              <input
+                type="checkbox"
+                :checked="item.checked"
+                @change="toggleListItemCheck(idx)"
+                class="lb-check"
+                tabindex="-1"
+              />
+              <input
+                :ref="(el) => { listItemRefs[idx] = el as HTMLInputElement | null }"
+                v-model="item.text"
+                class="lb-text"
+                placeholder="List item..."
+                @keydown="onListItemKeydown($event, idx)"
+                @input="onListItemInput(idx)"
+              />
+              <button class="lb-delete" tabindex="-1" @click="removeListItem(idx)" title="Remove item">&times;</button>
+            </div>
+            <button class="lb-add" @click="addListItem()">+ Add item</button>
+          </div>
+          <div class="notes-section">
+            <button class="notes-toggle" @click="notesExpanded = !notesExpanded">
+              {{ notesExpanded ? '▾' : '▸' }} Notes
+            </button>
+            <div v-if="notesExpanded" class="notes-editor-wrap">
+              <MarkdownToolbar v-show="!showPreview" :editor="tiptapEditor" />
+              <TiptapEditor
+                ref="editorRef"
+                :modelValue="body"
+                placeholder="Additional notes, context..."
+                @update:modelValue="onBodyUpdate"
+                @escape="titleRef?.focus()"
+              />
+            </div>
+          </div>
+        </template>
+
+        <!-- ── Generic note editor ──────────────────────────────── -->
+        <template v-else>
+          <div class="body-tabs-row">
+            <div class="editor-tabs">
+              <button :class="['tab', { active: !showPreview }]" @click="showPreview = false">Write</button>
+              <button :class="['tab', { active: showPreview }]" @click="showPreview = true">Preview</button>
+            </div>
+            <MarkdownToolbar v-show="!showPreview && assist.state.value === 'idle'" :editor="tiptapEditor" />
+          </div>
+
+          <!-- Streaming preview -->
+          <template v-if="assist.state.value === 'streaming'">
+            <div class="stream-label">Generating...</div>
+            <div class="stream-preview prose" v-html="renderMarkdown(assist.streamingText.value)" />
+          </template>
+
+          <!-- Review: full-document diff -->
+          <template v-else-if="assist.state.value === 'review'">
+            <DiffView :diff="assist.diff.value" class="main-diff" />
+          </template>
+
+          <!-- Normal editor -->
+          <template v-else>
+            <Transition name="tab-fade" mode="out-in">
+              <div v-if="!showPreview" class="body-editor-wrap">
+                <TiptapEditor
+                  ref="editorRef"
+                  :modelValue="body"
+                  placeholder="Write your note in Markdown..."
+                  @update:modelValue="onBodyUpdate"
+                  @selectionChange="onSelectionChange"
+                  @escape="titleRef?.focus()"
+                />
+              </div>
+              <div
+                v-else
+                class="preview-pane prose"
+                v-html="renderedPreview"
+              />
+            </Transition>
+          </template>
+
+          <!-- Error from assist -->
+          <div v-if="assist.error.value" class="assist-error">{{ assist.error.value }}</div>
+        </template>
       </div>
 
       <!-- ── Sidebar ──────────────────────────────────────────── -->
@@ -476,38 +708,6 @@ onUnmounted(() => assist.clearSelection());
             </select>
           </div>
 
-          <!-- Person metadata -->
-          <template v-if="noteType === 'person'">
-            <div class="sb-field">
-              <label class="sb-label">Relationship</label>
-              <input class="sb-input" v-model="entityMeta.relationship" placeholder="e.g. Friend, Colleague" @input="markDirty" />
-            </div>
-            <div class="sb-field">
-              <label class="sb-label">Email</label>
-              <input class="sb-input" v-model="entityMeta.email" type="email" placeholder="email@example.com" @input="markDirty" />
-            </div>
-            <div class="sb-field">
-              <label class="sb-label">Phone</label>
-              <input class="sb-input" v-model="entityMeta.phone" type="tel" placeholder="+1 555 000 0000" @input="markDirty" />
-            </div>
-          </template>
-
-          <!-- Place metadata -->
-          <template v-if="noteType === 'place'">
-            <div class="sb-field">
-              <label class="sb-label">Address</label>
-              <input class="sb-input" v-model="entityMeta.address" placeholder="Street, City" @input="markDirty" />
-            </div>
-            <div class="sb-field">
-              <label class="sb-label">Phone</label>
-              <input class="sb-input" v-model="entityMeta.phone" type="tel" placeholder="+1 555 000 0000" @input="markDirty" />
-            </div>
-            <div class="sb-field">
-              <label class="sb-label">Hours</label>
-              <input class="sb-input" v-model="entityMeta.hours" placeholder="e.g. Mon–Fri 9–5" @input="markDirty" />
-            </div>
-          </template>
-
           <!-- Link Suggestions -->
           <div v-if="linkSuggestions.length > 0" class="sb-field link-suggest-field">
             <div class="sb-label-row">
@@ -731,7 +931,7 @@ onUnmounted(() => assist.clearSelection());
   transition: border-color 0.15s;
 }
 .sb-select:focus, .sb-input:focus {
-  border-color: var(--color-primary, #6366f1);
+  border-color: var(--color-primary);
 }
 
 /* Tag suggest row inside sidebar */
@@ -819,6 +1019,138 @@ onUnmounted(() => assist.clearSelection());
   letter-spacing: 0.05em;
 }
 
+/* ── Entity form (Person / Place) ───────────────────────── */
+.entity-form {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 16px 0;
+}
+.ef-field {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.ef-label {
+  font-family: 'Fraunces', Georgia, serif;
+  font-style: italic;
+  font-size: 0.78rem;
+  color: var(--color-primary);
+}
+.ef-input {
+  padding: 8px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-surface);
+  color: var(--color-text);
+  font-size: 0.9rem;
+  font-family: inherit;
+  outline: none;
+  transition: border-color 0.15s;
+}
+.ef-input:focus {
+  border-color: var(--color-primary);
+  box-shadow: var(--focus-ring);
+}
+.ef-input::placeholder {
+  color: var(--color-text-muted);
+}
+
+/* ── Notes section (collapsible TipTap) ─────────────────── */
+.notes-section {
+  margin-top: 16px;
+  border-top: 1px solid var(--color-border);
+  padding-top: 12px;
+}
+.notes-toggle {
+  background: none;
+  border: none;
+  color: var(--color-primary);
+  font-family: 'Fraunces', Georgia, serif;
+  font-style: italic;
+  font-size: 0.85rem;
+  cursor: pointer;
+  padding: 4px 0;
+}
+.notes-toggle:hover {
+  color: var(--color-text);
+}
+.notes-editor-wrap {
+  margin-top: 8px;
+}
+
+/* ── List builder ───────────────────────────────────────── */
+.list-builder {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 12px 0;
+}
+.lb-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.lb-check {
+  flex-shrink: 0;
+  width: 18px;
+  height: 18px;
+  accent-color: var(--color-primary);
+  cursor: pointer;
+}
+.lb-text {
+  flex: 1;
+  padding: 7px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-surface);
+  color: var(--color-text);
+  font-size: 0.9rem;
+  font-family: inherit;
+  outline: none;
+  transition: border-color 0.15s;
+}
+.lb-text:focus {
+  border-color: var(--color-primary);
+  box-shadow: var(--focus-ring);
+}
+.lb-text::placeholder {
+  color: var(--color-text-muted);
+}
+.lb-delete {
+  background: none;
+  border: none;
+  color: var(--color-text-muted);
+  font-size: 1.1rem;
+  cursor: pointer;
+  padding: 0 4px;
+  line-height: 1;
+  opacity: 0;
+  transition: opacity 0.12s, color 0.12s;
+}
+.lb-item:hover .lb-delete,
+.lb-text:focus ~ .lb-delete {
+  opacity: 1;
+}
+.lb-delete:hover {
+  color: var(--color-danger);
+}
+.lb-add {
+  background: none;
+  border: 1px dashed var(--color-border);
+  border-radius: 8px;
+  padding: 7px 12px;
+  color: var(--color-text-muted);
+  font-size: 0.85rem;
+  cursor: pointer;
+  margin-top: 4px;
+  transition: border-color 0.15s, color 0.15s;
+}
+.lb-add:hover {
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+}
+
 /* Narrow screen: sidebar collapses */
 @media (max-width: 720px) {
   .note-body { flex-direction: column; overflow-y: auto; overflow-x: hidden; }

frontend/src/views/NoteViewerView.vue

@@ -350,17 +350,17 @@ async function convertToTask() {
   padding: 0.45rem 1.1rem;
   border: none;
   border-radius: var(--radius-sm);
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   text-decoration: none;
   cursor: pointer;
   font-size: 0.875rem;
   font-weight: 600;
-  box-shadow: 0 2px 8px rgba(99, 102, 241, 0.28);
+  box-shadow: var(--glow-cta);
   transition: box-shadow 0.15s, opacity 0.15s;
 }
 .btn-edit:hover {
-  box-shadow: 0 4px 14px rgba(99, 102, 241, 0.42);
+  box-shadow: var(--glow-cta-hover);
   opacity: 0.95;
   color: #fff;
 }

frontend/src/views/ProjectListView.vue

@@ -20,7 +20,7 @@ interface Project {
   title: string;
   description: string | null;
   goal: string | null;
-  status: "active" | "completed" | "archived";
+  status: "active" | "paused" | "completed" | "archived";
   color: string | null;
   auto_summary: string | null;
   permission?: string;
@@ -40,7 +40,7 @@ const toast = useToastStore();
 const projects = ref<Project[]>([]);
 const loading = ref(false);
 const error = ref<string | null>(null);
-const activeTab = ref<"all" | "active" | "completed" | "archived">("all");
+const activeTab = ref<"all" | "active" | "paused" | "completed" | "archived">("all");
 
 // New project modal
 const showNewProjectModal = ref(false);
@@ -103,6 +103,7 @@ async function createProject() {
 
 function statusLabel(status: Project["status"]): string {
   if (status === "active") return "Active";
+  if (status === "paused") return "Paused";
   if (status === "completed") return "Completed";
   if (status === "archived") return "Archived";
   return status;
@@ -112,6 +113,14 @@ function truncate(text: string | null, max = 120): string {
   if (!text) return "";
   return text.length > max ? text.slice(0, max) + "..." : text;
 }
+
+function overallPct(project: Project): { total: number; pct: number } {
+  const counts = project.summary?.task_counts;
+  if (!counts) return { total: 0, pct: 0 };
+  const total = (counts.todo ?? 0) + (counts.in_progress ?? 0) + (counts.done ?? 0);
+  const pct = total > 0 ? Math.round((counts.done ?? 0) / total * 100) : 0;
+  return { total, pct };
+}
 </script>
 
 <template>
@@ -124,7 +133,7 @@ function truncate(text: string | null, max = 120): string {
     <!-- Filter tabs -->
     <div class="filter-tabs">
       <button
-        v-for="tab in ['all', 'active', 'completed', 'archived'] as const"
+        v-for="tab in ['all', 'active', 'paused', 'completed', 'archived'] as const"
         :key="tab"
         :class="['tab-btn', { active: activeTab === tab }]"
         @click="activeTab = tab"
@@ -163,6 +172,18 @@ function truncate(text: string | null, max = 120): string {
         </p>
         <p v-if="project.description" class="project-desc">{{ truncate(project.description) }}</p>
 
+        <!-- Overall completion bar -->
+        <div
+          v-if="overallPct(project).total > 0"
+          class="overall-bar-row"
+          :title="`${project.summary?.task_counts.done ?? 0} of ${overallPct(project).total} tasks complete`"
+        >
+          <div class="overall-bar-track">
+            <div class="overall-bar-fill" :style="{ width: overallPct(project).pct + '%' }"></div>
+          </div>
+          <span class="overall-bar-pct">{{ overallPct(project).pct }}%</span>
+        </div>
+
         <!-- Milestone progress bars -->
         <div
           v-if="project.summary?.milestone_summary?.length"
@@ -416,6 +437,34 @@ function truncate(text: string | null, max = 120): string {
   line-height: 1.45;
 }
 
+.overall-bar-row {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  font-size: 0.72rem;
+  margin-top: 0.1rem;
+}
+.overall-bar-track {
+  flex: 1;
+  height: 6px;
+  background: var(--color-border);
+  border-radius: 999px;
+  overflow: hidden;
+}
+.overall-bar-fill {
+  height: 100%;
+  border-radius: 999px;
+  background: var(--color-primary);
+  transition: width 0.3s ease;
+}
+.overall-bar-pct {
+  color: var(--color-text-secondary);
+  flex-shrink: 0;
+  min-width: 2.5rem;
+  text-align: right;
+  font-weight: 600;
+}
+
 .milestone-bars {
   display: flex;
   flex-direction: column;

frontend/src/views/ProjectView.vue

@@ -23,7 +23,7 @@ interface Project {
   title: string;
   description: string | null;
   goal: string | null;
-  status: "active" | "completed" | "archived";
+  status: "active" | "paused" | "completed" | "archived";
   color: string | null;
   auto_summary: string | null;
   permission?: string;
@@ -118,6 +118,14 @@ function toggleMilestoneCollapse(id: number) {
   }
 }
 
+function autoCollapseCompleted(msList: Milestone[]) {
+  for (const ms of msList) {
+    if (ms.total > 0 && ms.completed === ms.total) {
+      collapsedMilestones.value.add(ms.id);
+    }
+  }
+}
+
 async function loadProject() {
   loading.value = true;
   error.value = null;
@@ -130,6 +138,7 @@ async function loadProject() {
     editStatus.value = data.status;
     editDirty.value = false;
     milestones.value = data.summary?.milestone_summary ?? [];
+    autoCollapseCompleted(milestones.value);
   } catch {
     error.value = "Failed to load project.";
   } finally {
@@ -143,6 +152,7 @@ async function loadMilestones() {
       `/api/projects/${projectId.value}/milestones`
     );
     milestones.value = data.milestones;
+    autoCollapseCompleted(milestones.value);
   } catch {
     // silent
   }
@@ -395,6 +405,7 @@ async function confirmDelete() {
             <label class="edit-label">Status</label>
             <select v-model="editStatus" class="edit-select">
               <option value="active">Active</option>
+              <option value="paused">Paused</option>
               <option value="completed">Completed</option>
               <option value="archived">Archived</option>
             </select>
@@ -676,17 +687,17 @@ async function confirmDelete() {
   align-items: center;
   gap: 0.35rem;
   padding: 0.45rem 1rem;
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: var(--radius-sm);
   font-size: 0.875rem;
   font-weight: 600;
   text-decoration: none;
-  box-shadow: 0 2px 8px rgba(99, 102, 241, 0.28);
+  box-shadow: var(--glow-cta);
   transition: box-shadow 0.15s, opacity 0.15s;
 }
-.btn-workspace:hover { box-shadow: 0 4px 14px rgba(99, 102, 241, 0.42); opacity: 0.95; color: #fff; }
+.btn-workspace:hover { box-shadow: var(--glow-cta-hover); opacity: 0.95; color: #fff; }
 
 .btn-share {
   padding: 0.4rem 0.8rem;
@@ -752,6 +763,7 @@ async function confirmDelete() {
   flex-shrink: 0;
 }
 .status-active   { background: color-mix(in srgb, var(--color-success) 14%, transparent); color: var(--color-success); border: 1px solid color-mix(in srgb, var(--color-success) 30%, transparent); }
+.status-paused    { background: color-mix(in srgb, var(--color-accent-warm) 14%, transparent); color: var(--color-accent-warm); border: 1px solid color-mix(in srgb, var(--color-accent-warm) 30%, transparent); }
 .status-completed { background: color-mix(in srgb, var(--color-primary) 14%, transparent); color: var(--color-primary); border: 1px solid color-mix(in srgb, var(--color-primary) 30%, transparent); }
 .status-archived  { background: color-mix(in srgb, var(--color-text-muted) 14%, transparent); color: var(--color-text-muted); border: 1px solid color-mix(in srgb, var(--color-text-muted) 30%, transparent); }
 
@@ -857,7 +869,7 @@ async function confirmDelete() {
 
 .btn-save-panel {
   padding: 0.45rem 0.9rem;
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: var(--radius-sm);
@@ -866,10 +878,10 @@ async function confirmDelete() {
   font-weight: 600;
   font-family: inherit;
   width: 100%;
-  box-shadow: 0 2px 8px rgba(99, 102, 241, 0.25);
+  box-shadow: var(--glow-soft);
   transition: box-shadow 0.15s, opacity 0.15s;
 }
-.btn-save-panel:hover:not(:disabled) { box-shadow: 0 4px 12px rgba(99, 102, 241, 0.4); opacity: 0.95; }
+.btn-save-panel:hover:not(:disabled) { box-shadow: 0 4px 12px rgba(124, 58, 237, 0.4); opacity: 0.95; }
 .btn-save-panel:disabled { opacity: 0.45; cursor: default; }
 
 /* ── Content area ────────────────────────────────────────────── */

frontend/src/views/SettingsView.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, watch, onMounted } from "vue";
+import { ref, computed, watch, onMounted } from "vue";
 import { useSettingsStore } from "@/stores/settings";
 import { useAuthStore } from "@/stores/auth";
 import { useToastStore } from "@/stores/toast";
@@ -94,17 +94,54 @@ const mcpInfo = ref<{ available: boolean; filename: string | null } | null>(null
 const mcpInfoLoading = ref(false);
 
 const origin = window.location.origin;
-const mcpConfigSnippet = JSON.stringify({
+const mcpClientTab = ref<'claude-code' | 'claude-desktop' | 'other'>('claude-code');
+const copiedSnippetKey = ref<string | null>(null);
+
+const effectiveApiKey = computed(() => newKeyValue.value || '<your-api-key>');
+
+const claudeCodeCommand = computed(() => {
+  return `claude mcp add --transport stdio --scope user fable \\
+  --env FABLE_URL=${origin} \\
+  --env FABLE_API_KEY=${effectiveApiKey.value} \\
+  -- fable-mcp`;
+});
+
+const mcpConfigSnippet = computed(() => JSON.stringify({
   mcpServers: {
     fable: {
       command: "fable-mcp",
       env: {
-        FABLE_URL: window.location.origin,
-        FABLE_API_KEY: "<your-api-key>",
+        FABLE_URL: origin,
+        FABLE_API_KEY: effectiveApiKey.value,
       },
     },
   },
-}, null, 2);
+}, null, 2));
+
+async function copyToClipboard(text: string) {
+  try {
+    await navigator.clipboard.writeText(text);
+  } catch {
+    // Fallback for http (non-secure) contexts where clipboard API is unavailable
+    const ta = document.createElement('textarea');
+    ta.value = text;
+    ta.style.position = 'fixed';
+    ta.style.opacity = '0';
+    document.body.appendChild(ta);
+    ta.focus();
+    ta.select();
+    document.execCommand('copy');
+    document.body.removeChild(ta);
+  }
+}
+
+async function copySnippet(text: string, key: string) {
+  await copyToClipboard(text);
+  copiedSnippetKey.value = key;
+  setTimeout(() => {
+    if (copiedSnippetKey.value === key) copiedSnippetKey.value = null;
+  }, 2000);
+}
 
 async function loadMcpInfo() {
   if (mcpInfo.value !== null) return;
@@ -142,20 +179,7 @@ async function revokeApiKey(id: number) {
 }
 
 async function copyApiKey() {
-  try {
-    await navigator.clipboard.writeText(newKeyValue.value);
-  } catch {
-    // Fallback for http (non-secure) contexts where clipboard API is unavailable
-    const ta = document.createElement('textarea');
-    ta.value = newKeyValue.value;
-    ta.style.position = 'fixed';
-    ta.style.opacity = '0';
-    document.body.appendChild(ta);
-    ta.focus();
-    ta.select();
-    document.execCommand('copy');
-    document.body.removeChild(ta);
-  }
+  await copyToClipboard(newKeyValue.value);
   apiKeyCopied.value = true;
   setTimeout(() => { apiKeyCopied.value = false; }, 2000);
 }
@@ -363,6 +387,14 @@ async function saveBriefingSettings() {
   }
 }
 
+async function toggleRss() {
+  try {
+    await store.updateSettings({ rss_enabled: store.rssEnabled ? "false" : "true" });
+  } catch {
+    toastStore.show("Failed to update RSS setting", "error");
+  }
+}
+
 async function addFeed() {
   if (!newFeedUrl.value.trim() || addingFeed.value) return;
   addingFeed.value = true;
@@ -2185,8 +2217,20 @@ function formatUserDate(iso: string): string {
         </p>
       </section>
 
-      <!-- RSS Feeds -->
+      <!-- RSS toggle -->
       <section class="settings-section full-width">
+        <h2>RSS / News</h2>
+        <div class="checkbox-field">
+          <label>
+            <input type="checkbox" :checked="store.rssEnabled" @change="toggleRss" />
+            Enable RSS feeds
+          </label>
+          <p class="field-hint">Subscribe to RSS/Atom feeds and include news in your briefings.</p>
+        </div>
+      </section>
+
+      <!-- RSS Feeds -->
+      <section v-if="store.rssEnabled" class="settings-section full-width">
         <div class="briefing-feeds-header">
           <div>
             <h2>RSS Feeds</h2>
@@ -2228,7 +2272,7 @@ function formatUserDate(iso: string): string {
       </section>
 
       <!-- News Preferences -->
-      <section class="settings-section full-width">
+      <section v-if="store.rssEnabled" class="settings-section full-width">
         <h2>News Preferences</h2>
         <p class="section-desc">
           Tell the briefing what topics you care about. Topics are matched against
@@ -2529,21 +2573,113 @@ function formatUserDate(iso: string): string {
 
             <div class="mcp-install-steps">
               <h3>Installation</h3>
-              <ol>
+
+              <div class="mcp-client-tabs" role="tablist">
+                <button
+                  type="button"
+                  role="tab"
+                  :aria-selected="mcpClientTab === 'claude-code'"
+                  :class="['mcp-client-tab', { active: mcpClientTab === 'claude-code' }]"
+                  @click="mcpClientTab = 'claude-code'"
+                >Claude Code</button>
+                <button
+                  type="button"
+                  role="tab"
+                  :aria-selected="mcpClientTab === 'claude-desktop'"
+                  :class="['mcp-client-tab', { active: mcpClientTab === 'claude-desktop' }]"
+                  @click="mcpClientTab = 'claude-desktop'"
+                >Claude Desktop</button>
+                <button
+                  type="button"
+                  role="tab"
+                  :aria-selected="mcpClientTab === 'other'"
+                  :class="['mcp-client-tab', { active: mcpClientTab === 'other' }]"
+                  @click="mcpClientTab = 'other'"
+                >Other</button>
+              </div>
+
+              <!-- Claude Code tab -->
+              <ol v-if="mcpClientTab === 'claude-code'">
                 <li>
-                  Download the wheel above and install it:
-                  <pre class="mcp-code">pip install {{ mcpInfo.filename }}</pre>
+                  Download the wheel above and install it with <a href="https://docs.astral.sh/uv/" target="_blank" rel="noopener">uv</a> or <a href="https://pipx.pypa.io/" target="_blank" rel="noopener">pipx</a> — either one works:
+                  <div class="mcp-code-row">
+                    <pre class="mcp-code">uv tool install ./{{ mcpInfo.filename }}</pre>
+                    <button class="btn btn-secondary btn-sm" @click="copySnippet(`uv tool install ./${mcpInfo.filename}`, 'cc-install-uv')">
+                      {{ copiedSnippetKey === 'cc-install-uv' ? 'Copied' : 'Copy' }}
+                    </button>
+                  </div>
+                  <div class="mcp-code-row">
+                    <pre class="mcp-code">pipx install ./{{ mcpInfo.filename }}</pre>
+                    <button class="btn btn-secondary btn-sm" @click="copySnippet(`pipx install ./${mcpInfo.filename}`, 'cc-install-pipx')">
+                      {{ copiedSnippetKey === 'cc-install-pipx' ? 'Copied' : 'Copy' }}
+                    </button>
+                  </div>
+                  <p class="mcp-hint">This puts <code>fable-mcp</code> on your PATH so Claude Code can launch it.</p>
                 </li>
                 <li>
-                  Create a <code>.env</code> file (or set environment variables):
-                  <pre class="mcp-code">FABLE_URL={{ origin }}
-FABLE_API_KEY=&lt;your-api-key&gt;</pre>
+                  Register the server with Claude Code:
+                  <div class="mcp-code-row">
+                    <pre class="mcp-code">{{ claudeCodeCommand }}</pre>
+                    <button class="btn btn-secondary btn-sm" @click="copySnippet(claudeCodeCommand, 'cc-add')">
+                      {{ copiedSnippetKey === 'cc-add' ? 'Copied' : 'Copy' }}
+                    </button>
+                  </div>
+                  <p class="mcp-hint">
+                    <code>--scope user</code> makes <code>fable</code> available across all your projects. Use <code>--scope project</code> to write it into the current repo's <code>.mcp.json</code> instead, or <code>--scope local</code> for this machine and repo only.
+                    <span v-if="!newKeyValue"> Generate an API key above to pre-fill the command.</span>
+                  </p>
                 </li>
                 <li>
-                  Add to your Claude MCP config (<code>~/.claude.json</code> or the Claude Desktop config):
-                  <pre class="mcp-code">{{ mcpConfigSnippet }}</pre>
+                  Verify the connection by running <code>/mcp</code> inside Claude Code — <code>fable</code> should appear as connected.
                 </li>
               </ol>
+
+              <!-- Claude Desktop tab -->
+              <ol v-else-if="mcpClientTab === 'claude-desktop'">
+                <li>
+                  Download the wheel above and install it with uv or pipx:
+                  <div class="mcp-code-row">
+                    <pre class="mcp-code">uv tool install ./{{ mcpInfo.filename }}</pre>
+                    <button class="btn btn-secondary btn-sm" @click="copySnippet(`uv tool install ./${mcpInfo.filename}`, 'cd-install')">
+                      {{ copiedSnippetKey === 'cd-install' ? 'Copied' : 'Copy' }}
+                    </button>
+                  </div>
+                </li>
+                <li>
+                  Add this block to your Claude Desktop MCP config file (<code>~/Library/Application Support/Claude/claude_desktop_config.json</code> on macOS, <code>%APPDATA%\Claude\claude_desktop_config.json</code> on Windows):
+                  <div class="mcp-code-row">
+                    <pre class="mcp-code">{{ mcpConfigSnippet }}</pre>
+                    <button class="btn btn-secondary btn-sm" @click="copySnippet(mcpConfigSnippet, 'cd-config')">
+                      {{ copiedSnippetKey === 'cd-config' ? 'Copied' : 'Copy' }}
+                    </button>
+                  </div>
+                </li>
+                <li>
+                  Restart Claude Desktop. The Fable tools should appear in the available tools list.
+                </li>
+              </ol>
+
+              <!-- Other tab -->
+              <div v-else class="mcp-other">
+                <p>
+                  Any MCP-compatible client can launch <code>fable-mcp</code> over stdio. The exact setup depends on the client, but in general you'll need:
+                </p>
+                <ul class="mcp-plain-list">
+                  <li>Install the wheel: <code>uv tool install ./{{ mcpInfo.filename }}</code> or <code>pipx install ./{{ mcpInfo.filename }}</code></li>
+                  <li>Command: <code>fable-mcp</code></li>
+                  <li>Transport: <code>stdio</code></li>
+                  <li>Environment variables:
+                    <div class="mcp-code-row">
+                      <pre class="mcp-code">FABLE_URL={{ origin }}
+FABLE_API_KEY={{ effectiveApiKey }}</pre>
+                      <button class="btn btn-secondary btn-sm" @click="copySnippet(`FABLE_URL=${origin}\nFABLE_API_KEY=${effectiveApiKey}`, 'other-env')">
+                        {{ copiedSnippetKey === 'other-env' ? 'Copied' : 'Copy' }}
+                      </button>
+                    </div>
+                  </li>
+                </ul>
+                <p class="mcp-hint">Consult your MCP client's documentation for how to register a stdio server. These instructions have only been tested with Claude Code.</p>
+              </div>
             </div>
           </div>
           <div v-else class="mcp-unavailable">
@@ -3024,7 +3160,7 @@ FABLE_API_KEY=&lt;your-api-key&gt;</pre>
 }
 .sidebar-item.active {
   color: var(--color-primary);
-  background: rgba(99, 102, 241, 0.08);
+  background: rgba(124, 58, 237, 0.08);
   border-left-color: var(--color-primary);
   font-weight: 600;
 }
@@ -3489,7 +3625,7 @@ FABLE_API_KEY=&lt;your-api-key&gt;</pre>
   }
   .sidebar-item.active {
     border-bottom-color: var(--color-primary);
-    background: rgba(99, 102, 241, 0.08);
+    background: var(--color-primary-tint);
   }
   .settings-grid {
     grid-template-columns: 1fr;
@@ -4215,6 +4351,54 @@ FABLE_API_KEY=&lt;your-api-key&gt;</pre>
   white-space: pre-wrap;
   word-break: break-all;
   overflow-x: auto;
+  flex: 1;
+}
+.mcp-client-tabs {
+  display: flex;
+  gap: 0.25rem;
+  margin-bottom: 1rem;
+  border-bottom: 1px solid var(--color-border);
+}
+.mcp-client-tab {
+  background: transparent;
+  border: none;
+  padding: 0.5rem 0.9rem;
+  font-size: 0.85rem;
+  color: var(--color-text-muted);
+  cursor: pointer;
+  border-bottom: 2px solid transparent;
+  margin-bottom: -1px;
+  transition: color 0.15s, border-color 0.15s;
+}
+.mcp-client-tab:hover { color: var(--color-text); }
+.mcp-client-tab.active {
+  color: var(--color-primary);
+  border-bottom-color: var(--color-primary);
+  font-weight: 600;
+}
+.mcp-code-row {
+  display: flex;
+  align-items: stretch;
+  gap: 0.4rem;
+  margin-top: 0.4rem;
+}
+.mcp-code-row .mcp-code { margin-top: 0; }
+.mcp-code-row .btn-sm { white-space: nowrap; }
+.mcp-hint {
+  margin-top: 0.5rem;
+  font-size: 0.8rem;
+  opacity: 0.7;
+  line-height: 1.5;
+}
+.mcp-other p { font-size: 0.9rem; line-height: 1.6; }
+.mcp-plain-list {
+  list-style: disc;
+  padding-left: 1.25rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  font-size: 0.9rem;
+  line-height: 1.6;
 }
 
 /* Voice tab */

frontend/src/views/TaskEditorView.vue

@@ -362,7 +362,7 @@ async function confirmDelete() {
     await store.deleteTask(taskId.value);
     dirty.value = false;
     toast.show("Task deleted");
-    router.push("/tasks");
+    router.push(projectId.value ? `/projects/${projectId.value}` : "/");
   } catch {
     toast.show("Failed to delete task", "error");
   }
@@ -410,7 +410,7 @@ useEditorGuards(dirty, save);
   <main class="editor-page task-editor-page">
     <div class="editor-header">
       <div class="toolbar">
-        <router-link to="/tasks" class="btn-back">← Tasks</router-link>
+        <router-link :to="projectId ? `/projects/${projectId}` : '/'" class="btn-back">← {{ projectId ? 'Project' : 'Knowledge' }}</router-link>
         <button class="btn-save" @click="save" :disabled="saving">
           {{ saving ? "Saving..." : "Save" }}
         </button>

frontend/src/views/TaskViewerView.vue

@@ -480,23 +480,23 @@ const subTaskProgress = computed(() => {
   padding: 0.45rem 1.1rem;
   border: none;
   border-radius: var(--radius-sm);
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   text-decoration: none;
   cursor: pointer;
   font-size: 0.875rem;
   font-weight: 600;
-  box-shadow: 0 2px 8px rgba(99, 102, 241, 0.28);
+  box-shadow: var(--glow-cta);
   transition: box-shadow 0.15s, opacity 0.15s;
 }
 .btn-edit:hover {
-  box-shadow: 0 4px 14px rgba(99, 102, 241, 0.42);
+  box-shadow: var(--glow-cta-hover);
   opacity: 0.95;
   color: #fff;
 }
 .btn-advance {
   padding: 0.45rem 1rem;
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: var(--gradient-cta);
   color: #fff;
   border: none;
   border-radius: var(--radius-sm);

frontend/src/views/WorkspaceView.vue

@@ -75,8 +75,11 @@ watch(
         noteEditorRef.value?.reload();
       }
       if (
-        ["create_task", "update_task", "create_milestone", "update_milestone"].includes(tc.function) &&
-        tc.status === "success"
+        tc.status === "success" && (
+          ["create_milestone", "update_milestone"].includes(tc.function) ||
+          (tc.function === "create_note" && tc.result?.data?.status) ||
+          (tc.function === "update_note" && tc.result?.data?.status !== undefined)
+        )
       ) {
         taskPanelRef.value?.reload();
       }
@@ -135,8 +138,7 @@ onMounted(async () => {
 
   if (workspaceConvId === null) {
     // Create a new workspace conversation and persist its ID
-    const title = project.value ? `${project.value.title} — Workspace` : "Workspace";
-    const conv = await chatStore.createConversation(title);
+    const conv = await chatStore.createConversation();
     workspaceConvId = conv.id;
     isNewConv = true;
     await chatStore.fetchConversation(conv.id);

frontend/vite.config.ts

@@ -1,9 +1,39 @@
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
+import { viteStaticCopy } from "vite-plugin-static-copy";
 import { resolve } from "path";
 
 export default defineConfig({
-  plugins: [vue()],
+  plugins: [
+    vue(),
+    // @ricky0123/vad-web ships ONNX + audio-worklet assets and depends on
+    // onnxruntime-web's WASM binaries. Copy them into the served root so
+    // MicVAD can load them at runtime via `baseAssetPath: "/"`.
+    viteStaticCopy({
+      targets: [
+        {
+          src: "node_modules/@ricky0123/vad-web/dist/*.onnx",
+          dest: "",
+          rename: { stripBase: true },
+        },
+        {
+          src: "node_modules/@ricky0123/vad-web/dist/vad.worklet.bundle.min.js",
+          dest: "",
+          rename: { stripBase: true },
+        },
+        {
+          src: "node_modules/onnxruntime-web/dist/*.wasm",
+          dest: "",
+          rename: { stripBase: true },
+        },
+        {
+          src: "node_modules/onnxruntime-web/dist/*.mjs",
+          dest: "",
+          rename: { stripBase: true },
+        },
+      ],
+    }),
+  ],
   resolve: {
     alias: {
       "@": resolve(__dirname, "src"),

infra/Dockerfile.runner-base

@@ -1,26 +1,28 @@
 # Runner base image for Forgejo act_runner job containers.
-# Pre-installs Python 3.12 and Node 20 so the test job skips the
-# ~3-4 minute deadsnakes PPA install on every run.
+# Pre-installs Python 3.12, Node 22, uv, and ruff so workflows skip
+# lengthy runtime installs on every run.
 #
-# Build and push (one-time setup, re-run if this file changes):
+# Build and push (re-run when this file changes):
 #   docker build -f infra/Dockerfile.runner-base \
-#     -t git.fabledsword.com/bvandeusen/runner-base:py3.12-node22 .
-#   docker push git.fabledsword.com/bvandeusen/runner-base:py3.12-node22
+#     -t git.fabledsword.com/bvandeusen/runner-base:ci-runner .
+#   docker push git.fabledsword.com/bvandeusen/runner-base:ci-runner
 #
-# Then redeploy the act_runner stack in Portainer to pick up the new label.
+# Then redeploy the act_runner stack in Portainer to pick up the new image.
 
 FROM ubuntu:24.04
 
 ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=UTC
 
-# Split into separate RUN steps so each pushed layer is smaller.
-# One combined layer would be ~280MB and exceeds the nginx upload timeout.
+# Split into separate RUN steps so each pushed layer is smaller — one
+# combined layer exceeds the nginx upload timeout on the self-hosted
+# Forgejo registry.
 
-# Python 3.12 ships in Ubuntu 24.04 main repos — no PPA needed.
+# Python 3.12 (ships in Ubuntu 24.04 main repos) + core tools
 RUN apt-get update -qq && \
     apt-get install -y -qq \
-      python3.12 python3.12-dev python3.12-venv python3-pip \
-      git curl ca-certificates gnupg && \
+      python3.12 python3.12-dev python3.12-venv \
+      git curl ca-certificates gnupg jq tzdata && \
     apt-get clean && rm -rf /var/lib/apt/lists/*
 
 # Node 22 LTS via NodeSource
@@ -33,3 +35,14 @@ RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
 RUN apt-get update -qq && \
     apt-get install -y -qq docker.io && \
     apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# uv — fast Python package installer/resolver (~10x faster than pip).
+# Used by test jobs instead of pip for venv creation + dep installs.
+RUN curl -LsSf https://astral.sh/uv/install.sh | env INSTALLER_NO_MODIFY_PATH=1 sh && \
+    mv /root/.local/bin/uv /usr/local/bin/ && \
+    mv /root/.local/bin/uvx /usr/local/bin/
+
+# ruff — Python linter. Baked in so the lint job is just
+# `ruff check src/` with zero install overhead.
+RUN curl -LsSf https://astral.sh/ruff/install.sh | env INSTALLER_NO_MODIFY_PATH=1 sh && \
+    mv /root/.local/bin/ruff /usr/local/bin/

src/fabledassistant/app.py

@@ -143,10 +143,14 @@ def create_app() -> Quart:
         response.headers.setdefault("Referrer-Policy", "strict-origin-when-cross-origin")
         response.headers.setdefault(
             "Content-Security-Policy",
-            "default-src 'self'; script-src 'self' 'unsafe-inline'; "
-            "style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; "
-            "connect-src 'self'; font-src 'self' data:; object-src 'none'; "
-            "base-uri 'self'; worker-src 'self';"
+            "default-src 'self'; "
+            "script-src 'self' 'unsafe-inline' 'wasm-unsafe-eval'; "
+            "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "
+            "img-src 'self' data: blob:; "
+            "connect-src 'self'; "
+            "font-src 'self' data: https://fonts.gstatic.com; "
+            "object-src 'none'; "
+            "base-uri 'self'; worker-src 'self' blob:;"
         )
 
         return response
@@ -169,11 +173,12 @@ def create_app() -> Quart:
 
         async def _warm_model(model: str) -> None:
             """Warm an already-installed model into VRAM (no pull)."""
+            from fabledassistant.services.llm import keep_alive_for
             try:
                 async with httpx.AsyncClient(timeout=300.0) as client:
                     await client.post(
                         f"{Config.OLLAMA_URL}/api/generate",
-                        json={"model": model, "prompt": "", "keep_alive": "2h"},
+                        json={"model": model, "prompt": "", "keep_alive": keep_alive_for(model)},
                     )
                 logger.info("Warmed model '%s' into VRAM", model)
             except Exception:
@@ -187,14 +192,17 @@ def create_app() -> Quart:
             The num_ctx must match what real requests will use so Ollama doesn't reload.
             """
             try:
-                from fabledassistant.services.llm import build_context, pick_num_ctx
+                from fabledassistant.services.llm import build_context, keep_alive_for, pick_num_ctx
+                from fabledassistant.services.tools import get_tools_for_user
                 messages, _ = await build_context(
                     user_id=user_id,
                     history=[],
                     current_note_id=None,
                     user_message=" ",
                 )
-                num_ctx = pick_num_ctx(messages)
+                # Include tool schemas so num_ctx matches real chat requests.
+                tools = await get_tools_for_user(user_id)
+                num_ctx = pick_num_ctx(messages, tools=tools)
                 async with httpx.AsyncClient(timeout=120.0) as client:
                     await client.post(
                         f"{Config.OLLAMA_URL}/api/chat",
@@ -203,7 +211,7 @@ def create_app() -> Quart:
                             "messages": messages,
                             "stream": False,
                             "options": {"num_predict": 1, "num_ctx": num_ctx},
-                            "keep_alive": "2h",
+                            "keep_alive": keep_alive_for(model),
                         },
                     )
                 logger.info("Primed KV cache for user %d with model '%s' (num_ctx=%d)", user_id, model, num_ctx)

src/fabledassistant/config.py

@@ -27,7 +27,13 @@ class Config:
     # Lightweight model for background tasks (title generation, tag suggestions,
     # project summaries, RSS classification). Using a separate model keeps the
     # main model's KV cache intact between user messages, enabling prefix cache hits.
-    OLLAMA_BACKGROUND_MODEL: str = os.environ.get("OLLAMA_BACKGROUND_MODEL", "qwen2.5:3b")
+    OLLAMA_BACKGROUND_MODEL: str = os.environ.get("OLLAMA_BACKGROUND_MODEL", "gemma3:4b")
+    # Ollama keep_alive — how long a model stays resident in VRAM after its last
+    # request. Main model gets a longer window since it's used interactively;
+    # the background model is called sporadically and doesn't need to camp VRAM.
+    # Format matches Ollama's duration strings: "30m", "10m", "1h", "0s", "-1" (forever).
+    OLLAMA_KEEP_ALIVE_MAIN: str = os.environ.get("OLLAMA_KEEP_ALIVE_MAIN", "30m")
+    OLLAMA_KEEP_ALIVE_BACKGROUND: str = os.environ.get("OLLAMA_KEEP_ALIVE_BACKGROUND", "10m")
     # KV cache context window for generation. Keep this as small as practical —
     # a larger context forces more KV cache into CPU RAM, drastically slowing prefill.
     # 16384 covers ~30+ message conversations with our system prompt comfortably.

src/fabledassistant/models/rss_feed.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 
-from sqlalchemy import ARRAY, DateTime, ForeignKey, Index, Integer, Text, UniqueConstraint
+from sqlalchemy import ARRAY, BigInteger, DateTime, ForeignKey, Index, Integer, Text, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from fabledassistant.models import Base
@@ -46,6 +46,17 @@ class RssItem(Base):
     published_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
     # Truncated to 2000 chars to keep DB size reasonable
     content: Mapped[str] = mapped_column(Text, default="")
+    # Full trafilatura-extracted article body, populated lazily on first
+    # discuss-click / enrichment pass. Nullable — most items never get this
+    # cached. Expires naturally with the item (90-day retention).
+    content_full: Mapped[str | None] = mapped_column(Text, nullable=True)
+    # Map-reduced conversation-ready context derived from content_full. See
+    # services/article_context.py — populated on first discuss click so
+    # repeat clicks skip both the fetch and the LLM map step.
+    context_prepared: Mapped[str | None] = mapped_column(Text, nullable=True)
+    content_fetched_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
     fetched_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
     )
@@ -55,6 +66,13 @@ class RssItem(Base):
     classified_at: Mapped[datetime | None] = mapped_column(
         DateTime(timezone=True), nullable=True
     )
+    # Note persisting the first-click discussion summary. Set by the article
+    # discussion pipeline once the seeded chat completes its first assistant
+    # reply; links back into RAG so re-discussing the same article lands the
+    # prior summary in context.
+    discussion_note_id: Mapped[int | None] = mapped_column(
+        BigInteger, ForeignKey("notes.id", ondelete="SET NULL"), nullable=True
+    )
 
     feed: Mapped["RssFeed"] = relationship(back_populates="items")
 

src/fabledassistant/routes/briefing.py

@@ -54,11 +54,17 @@ async def put_config():
     return jsonify({"ok": True})
 
 
+async def _rss_enabled() -> bool:
+    return (await get_setting(g.user.id, "rss_enabled", "false")).lower() == "true"
+
+
 # ── RSS Feeds ─────────────────────────────────────────────────────────────────
 
 @briefing_bp.route("/feeds", methods=["GET"])
 @_REQUIRE
 async def list_feeds():
+    if not await _rss_enabled():
+        return jsonify([])
     async with async_session() as session:
         result = await session.execute(
             select(RssFeed).where(RssFeed.user_id == g.user.id).order_by(RssFeed.id)
@@ -70,6 +76,8 @@ async def list_feeds():
 @briefing_bp.route("/feeds", methods=["POST"])
 @_REQUIRE
 async def add_feed():
+    if not await _rss_enabled():
+        return jsonify({"error": "RSS is disabled"}), 403
     data = await request.get_json()
     url = (data.get("url") or "").strip()
     if not url:
@@ -120,6 +128,8 @@ async def delete_feed(feed_id: int):
 @briefing_bp.route("/feeds/refresh", methods=["POST"])
 @_REQUIRE
 async def refresh_feeds():
+    if not await _rss_enabled():
+        return jsonify({"feeds_refreshed": 0, "new_items": 0})
     results = await rss_svc.refresh_all_feeds(g.user.id)
     total_new = sum(results.values())
     return jsonify({"feeds_refreshed": len(results), "new_items": total_new})
@@ -128,6 +138,8 @@ async def refresh_feeds():
 @briefing_bp.route("/feeds/recent", methods=["GET"])
 @_REQUIRE
 async def recent_items():
+    if not await _rss_enabled():
+        return jsonify({"items": []})
     limit = min(int(request.args.get("limit", 20)), 100)
     items = await rss_svc.get_recent_items(g.user.id, limit=limit)
     return jsonify({"items": items})
@@ -155,6 +167,45 @@ async def get_weather():
     return jsonify({"locations": cards, "temp_unit": temp_unit})
 
 
+
+@briefing_bp.route("/weather/current", methods=["GET"])
+@_REQUIRE
+async def get_current_weather():
+    """Return current temperature, conditions, and precipitation for the user's primary location.
+
+    Lightweight — fetches live from Open-Meteo, no caching. Intended for periodic frontend polling.
+    """
+    raw = await get_setting(g.user.id, "briefing_config", "{}")
+    try:
+        config = json.loads(raw) if isinstance(raw, str) else (raw or {})
+        temp_unit = config.get("temp_unit", "C")
+        if temp_unit not in ("C", "F"):
+            temp_unit = "C"
+        locations = config.get("locations", {})
+    except Exception:
+        return jsonify({"error": "No briefing config"}), 404
+
+    # Use home location, fall back to work
+    loc = locations.get("home") or locations.get("work")
+    if not loc or not loc.get("lat") or not loc.get("lon"):
+        return jsonify({"error": "No location configured"}), 404
+
+    from fabledassistant.services.weather import fetch_current_conditions
+    current = await fetch_current_conditions(loc["lat"], loc["lon"])
+    if current is None:
+        return jsonify({"error": "Failed to fetch current conditions"}), 502
+
+    # Convert temperature if needed
+    temp = current["temperature"]
+    if temp is not None and temp_unit == "F":
+        temp = temp * 9 / 5 + 32
+    current["temperature"] = round(temp) if temp is not None else None
+    current["temp_unit"] = temp_unit
+    current["location"] = loc.get("label") or "Home"
+
+    return jsonify(current)
+
+
 @briefing_bp.route("/weather/geocode", methods=["POST"])
 @_REQUIRE
 async def geocode_location():
@@ -175,11 +226,14 @@ async def refresh_weather():
     raw = await get_setting(g.user.id, "briefing_config", "{}")
     try:
         config = json.loads(raw) if isinstance(raw, str) else {}
+        temp_unit = config.get("temp_unit", "C")
+        if temp_unit not in ("C", "F"):
+            temp_unit = "C"
     except Exception:
         config = {}
+        temp_unit = "C"
 
     locations = config.get("locations", {})
-    refreshed = []
     for key, loc in locations.items():
         if not loc.get("lat") or not loc.get("lon"):
             continue
@@ -191,11 +245,15 @@ async def refresh_weather():
                 lat=loc["lat"],
                 lon=loc["lon"],
             )
-            refreshed.append(key)
         except Exception:
             logger.warning("Failed to refresh weather for %s", key, exc_info=True)
 
-    return jsonify({"refreshed": refreshed})
+    rows = await weather_svc.get_cached_weather_rows(g.user.id)
+    cards = [
+        card for row in rows
+        if (card := weather_svc.parse_weather_card_data(row, temp_unit)) is not None
+    ]
+    return jsonify({"locations": cards, "temp_unit": temp_unit})
 
 
 # ── Briefing Conversations ─────────────────────────────────────────────────────
@@ -270,14 +328,55 @@ async def manual_trigger():
         logger.warning("Pre-trigger refresh failed for user %d", g.user.id, exc_info=True)
 
     from fabledassistant.services.briefing_pipeline import run_compilation
+    from fabledassistant.services.briefing_scheduler import _persist_agentic_messages
 
     model = await get_setting(g.user.id, "default_model", "")
     conv = await get_or_create_today_conversation(g.user.id, model)
     text, metadata = await run_compilation(g.user.id, slot, model)
-    msg = await post_message(conv.id, "assistant", text, metadata=metadata)
+    await _persist_agentic_messages(conv.id, slot, metadata)
+    final_meta = {k: v for k, v in metadata.items() if k != "agentic_messages"}
+    final_meta["briefing_slot"] = slot
+    msg = await post_message(conv.id, "assistant", text, metadata=final_meta)
     return jsonify({"conversation_id": conv.id, "message_id": msg.id, "slot": slot})
 
 
+@briefing_bp.route("/reset-today", methods=["POST"])
+@_REQUIRE
+async def reset_today_briefing():
+    """Delete all messages in today's briefing conversation.
+
+    The conversation row itself is kept so its id stays stable for any
+    open UI sessions. Intended for "wipe and start fresh" workflows
+    driven from the MCP when iterating on prompts. Pair with
+    ``POST /api/briefing/trigger`` to immediately regenerate.
+    """
+    from sqlalchemy import delete as _delete
+
+    from fabledassistant.services.tz import user_briefing_date
+
+    # User-local briefing day (flips at 4am local), not ``date.today()`` —
+    # see services/tz.py for rationale.
+    today = await user_briefing_date(g.user.id)
+    async with async_session() as session:
+        result = await session.execute(
+            select(Conversation).where(
+                Conversation.user_id == g.user.id,
+                Conversation.conversation_type == "briefing",
+                Conversation.briefing_date == today,
+            )
+        )
+        conv = result.scalars().first()
+        if conv is None:
+            return jsonify({"deleted": 0, "conversation_id": None})
+        deleted_result = await session.execute(
+            _delete(Message).where(Message.conversation_id == conv.id)
+        )
+        await session.commit()
+        deleted = deleted_result.rowcount or 0
+
+    return jsonify({"deleted": deleted, "conversation_id": conv.id})
+
+
 # ── RSS Reactions ──────────────────────────────────────────────────────────────
 
 @briefing_bp.route("/rss-reactions", methods=["POST"])
@@ -375,6 +474,9 @@ async def list_news():
       offset  — pagination offset (default 0)
       feed_id — optional integer filter by feed
     """
+    if not await _rss_enabled():
+        return jsonify({"items": [], "total": 0})
+
     from sqlalchemy import text as _text
 
     days = min(int(request.args.get("days", 2)), 90)
@@ -453,30 +555,122 @@ async def discuss_article(item_id: int):
     if get_buffer(conv_id) is not None:
         return jsonify({"error": "Generation already in progress"}), 409
 
-    from fabledassistant.services.rss import _fetch_full_article
-    article_content = await _fetch_full_article(item.url) or item.content or ""
+    # Shared helper handles the three-layer cache (context_prepared →
+    # content_full → fresh fetch), writes the synthetic read_article tool
+    # exchange and the conversational seed user prompt into the conversation.
+    # The /news from-article route calls the same helper so behavior stays
+    # byte-identical across entry points.
+    from fabledassistant.services.article_context import (
+        EmptyArticleError,
+        seed_article_discussion,
+    )
 
-    # Store synthetic assistant message with read_article tool result
-    synthetic_tool_calls = [{
-        "function": "read_article",
-        "arguments": {"url": item.url},
-        "result": {
-            "success": True,
-            "type": "article_content",
-            "url": item.url,
-            "content": article_content,
-            "truncated": False,
-        },
-    }]
-    await add_message(conv_id, "assistant", "", status="complete", tool_calls=synthetic_tool_calls)
-
-    # Store user message
-    await add_message(conv_id, "user", "Please summarize and discuss this article.")
+    model = await get_setting(uid, "default_model", "") or ""
+    try:
+        discuss_prompt = await seed_article_discussion(conv_id, item, model)
+    except EmptyArticleError as e:
+        return jsonify({"error": str(e)}), 422
 
     # Reload conversation with fresh messages to build history
     conv = await get_conversation(uid, conv_id)
     assert conv is not None
 
+    history = []
+    for msg in conv.messages:
+        if msg.role == "system":
+            continue
+        msg_dict = {"role": msg.role, "content": msg.content or ""}
+        if msg.tool_calls:
+            msg_dict["tool_calls"] = [
+                {"function": {"name": tc["function"], "arguments": tc["arguments"]}}
+                for tc in msg.tool_calls
+            ]
+            history.append(msg_dict)
+            for tc in msg.tool_calls:
+                history.append({"role": "tool", "content": json.dumps(tc.get("result", {}))})
+        else:
+            history.append(msg_dict)
+
+    assistant_msg = await add_message(conv_id, "assistant", "", status="generating")
+    buf = create_buffer(conv_id, assistant_msg.id)
+
+    asyncio.create_task(run_generation(
+        buf, history, model,
+        uid, conv_id, conv.title or "",
+        discuss_prompt,
+    ))
+
+    return jsonify({"assistant_message_id": assistant_msg.id, "status": "generating"}), 202
+
+
+@briefing_bp.route("/topics/<topic>/discuss", methods=["POST"])
+@_REQUIRE
+async def discuss_topic(topic: str):
+    """Discuss all recent articles in a topic cluster — multi-article deep analysis."""
+    data = await request.get_json() or {}
+    conv_id = data.get("conv_id")
+    if not conv_id:
+        return jsonify({"error": "conv_id required"}), 400
+
+    uid = g.user.id
+
+    # Verify conversation belongs to user
+    conv = await get_conversation(uid, conv_id)
+    if conv is None:
+        return jsonify({"error": "Conversation not found"}), 404
+
+    if get_buffer(conv_id) is not None:
+        return jsonify({"error": "Generation already in progress"}), 409
+
+    # Find recent articles with this topic (last 2 days)
+    async with async_session() as session:
+        result = await session.execute(
+            select(RssItem)
+            .join(RssFeed, RssFeed.id == RssItem.feed_id)
+            .where(RssFeed.user_id == uid)
+            .where(RssItem.topics.contains([topic]))
+            .order_by(RssItem.published_at.desc().nullslast())
+            .limit(5)
+        )
+        items = list(result.scalars().all())
+
+    if not items:
+        return jsonify({"error": f"No articles found for topic '{topic}'"}), 404
+
+    # Fetch full content for each article
+    from fabledassistant.services.rss import _fetch_full_article
+
+    synthetic_tool_calls = []
+    for item in items:
+        content = await _fetch_full_article(item.url) if item.url else None
+        content = content or item.content or ""
+        synthetic_tool_calls.append({
+            "function": "read_article",
+            "arguments": {"url": item.url or ""},
+            "result": {
+                "success": True,
+                "type": "article_content",
+                "url": item.url or "",
+                "title": item.title or "",
+                "source": "",
+                "content": content[:8000],  # cap per article to stay within context
+                "truncated": len(content) > 8000,
+            },
+        })
+
+    await add_message(conv_id, "assistant", "", status="complete", tool_calls=synthetic_tool_calls)
+
+    user_prompt = (
+        f"I'd like to discuss the {len(items)} articles about '{topic}'. "
+        "Don't just summarize each one — draw connections between the sources, "
+        "highlight where they agree or disagree, and share your analysis of what "
+        "this means. Let's have a real discussion about this topic."
+    )
+    await add_message(conv_id, "user", user_prompt)
+
+    conv = await get_conversation(uid, conv_id)
+    assert conv is not None
+
     history = []
     for msg in conv.messages:
         if msg.role == "system":
@@ -501,8 +695,11 @@ async def discuss_article(item_id: int):
     asyncio.create_task(run_generation(
         buf, history, model,
         uid, conv_id, conv.title or "",
-        "Please summarize and discuss this article.",
-        think=True,
+        user_prompt,
     ))
 
-    return jsonify({"assistant_message_id": assistant_msg.id, "status": "generating"}), 202
+    return jsonify({
+        "assistant_message_id": assistant_msg.id,
+        "status": "generating",
+        "article_count": len(items),
+    }), 202

src/fabledassistant/routes/chat.py

@@ -350,11 +350,12 @@ async def warm_model_route():
         return jsonify({"error": "model is required"}), 400
 
     async def _warm():
+        from fabledassistant.services.llm import keep_alive_for
         try:
             async with httpx.AsyncClient(timeout=300.0) as client:
                 await client.post(
                     f"{Config.OLLAMA_URL}/api/generate",
-                    json={"model": model, "prompt": "", "keep_alive": "30m"},
+                    json={"model": model, "prompt": "", "keep_alive": keep_alive_for(model)},
                 )
             logger.info("Warmed model %s", model)
         except Exception as e:
@@ -509,47 +510,78 @@ async def delete_model_route():
 @chat_bp.route("/from-article/<int:item_id>", methods=["POST"])
 @login_required
 async def create_conversation_from_article(item_id: int):
-    """Create a chat conversation seeded with an RSS article's content."""
+    """Create a chat conversation seeded for article discussion and auto-run.
+
+    Mirrors the briefing ``discuss_article`` route: creates a fresh
+    conversation, stages the shared synthetic read_article exchange + seed
+    prompt, then kicks off generation so the client lands on an in-flight
+    stream. The Flutter and web chat screens reconnect to the running buffer
+    on mount.
+    """
     from sqlalchemy import select as _select
     from fabledassistant.models import async_session as _async_session
-    from fabledassistant.models.conversation import Message
     from fabledassistant.models.rss_feed import RssItem, RssFeed
+    from fabledassistant.services.article_context import (
+        EmptyArticleError,
+        seed_article_discussion,
+    )
 
     uid = get_current_user_id()
 
     async with _async_session() as session:
         result = await session.execute(
-            _select(RssItem, RssFeed.title.label("feed_title"))
+            _select(RssItem)
             .join(RssFeed, RssItem.feed_id == RssFeed.id)
             .where(RssItem.id == item_id, RssFeed.user_id == uid)
         )
-        row = result.first()
+        item = result.scalars().first()
 
-    if row is None:
+    if item is None:
         return jsonify({"error": "Article not found"}), 404
 
-    item, feed_title = row
-
     conv_title = (item.title or "Article discussion")[:80]
     conv = await create_conversation(uid, title=conv_title, conversation_type="chat")
 
-    from fabledassistant.services.rss import _fetch_full_article
-    source = feed_title or "News"
-    content_body = (await _fetch_full_article(item.url) if item.url else None) or (item.content or "").strip()
-    seeded_text = f"**{source}**\n\n**{item.title}**"
-    if content_body:
-        seeded_text += f"\n\n{content_body}"
-    if item.url:
-        seeded_text += f"\n\nSource: {item.url}"
+    model = await get_setting(uid, "default_model", "") or Config.OLLAMA_MODEL
+    try:
+        discuss_prompt = await seed_article_discussion(conv.id, item, model)
+    except EmptyArticleError as e:
+        # Roll back the empty conversation so the user doesn't end up with a
+        # phantom entry in their chat list.
+        try:
+            await delete_conversation(uid, conv.id)
+        except Exception:
+            logger.warning("Failed to clean up empty article conversation %s", conv.id)
+        return jsonify({"error": str(e)}), 422
 
-    async with _async_session() as session:
-        msg = Message(
-            conversation_id=conv.id,
-            role="assistant",
-            content=seeded_text,
-            msg_metadata={"rss_item_ids": [item_id]},
-        )
-        session.add(msg)
-        await session.commit()
+    # Reload conversation so we see the two messages the helper just added.
+    conv = await get_conversation(uid, conv.id)
+    assert conv is not None
 
-    return jsonify({"conversation_id": conv.id}), 201
+    history: list[dict] = []
+    for msg in conv.messages:
+        if msg.role == "system":
+            continue
+        msg_dict: dict = {"role": msg.role, "content": msg.content or ""}
+        if msg.tool_calls:
+            msg_dict["tool_calls"] = [
+                {"function": {"name": tc["function"], "arguments": tc["arguments"]}}
+                for tc in msg.tool_calls
+            ]
+            history.append(msg_dict)
+            for tc in msg.tool_calls:
+                history.append({"role": "tool", "content": json.dumps(tc.get("result", {}))})
+        else:
+            history.append(msg_dict)
+
+    assistant_msg = await add_message(conv.id, "assistant", "", status="generating")
+    buf = create_buffer(conv.id, assistant_msg.id)
+    asyncio.create_task(run_generation(
+        buf, history, model, uid, conv.id, conv.title or "", discuss_prompt,
+    ))
+
+    return jsonify({
+        "conversation_id": conv.id,
+        "assistant_message_id": assistant_msg.id,
+        "status": "generating",
+    }), 202

src/fabledassistant/routes/projects.py

@@ -52,7 +52,7 @@ async def create_project_route():
     if not data.get("title"):
         return jsonify({"error": "title is required"}), 400
     status = data.get("status", "active")
-    if status not in ("active", "completed", "archived"):
+    if status not in ("active", "paused", "completed", "archived"):
         return jsonify({"error": "status must be 'active', 'completed', or 'archived'"}), 400
     project = await create_project(
         uid,
@@ -88,8 +88,8 @@ async def update_project_route(project_id: int):
     uid = get_current_user_id()
     data = await request.get_json()
     allowed = {"title", "description", "goal", "status", "color"}
-    fields = {k: v for k, v in data.items() if k in allowed}
-    if "status" in fields and fields["status"] not in ("active", "completed", "archived"):
+    fields = {k: (v if v is not None else "") for k, v in data.items() if k in allowed}
+    if "status" in fields and fields["status"] not in ("active", "paused", "completed", "archived"):
         return jsonify({"error": "status must be 'active', 'completed', or 'archived'"}), 400
     project = await update_project(uid, project_id, **fields)
     if project is None:

src/fabledassistant/routes/quick_capture.py

@@ -11,7 +11,6 @@ from quart import Blueprint, jsonify, request
 
 from fabledassistant.auth import get_current_user_id, login_required
 from fabledassistant.config import Config
-from fabledassistant.services.generation_task import _should_think
 from fabledassistant.services.llm import stream_chat_with_tools
 from fabledassistant.services.tools import execute_tool, get_tools_for_user
 
@@ -21,7 +20,7 @@ quick_capture_bp = Blueprint("quick_capture", __name__, url_prefix="/api/quick-c
 
 # Tools offered to the quick-capture endpoint. Excludes destructive ops,
 # read-only queries, and conversational-only tools.
-_CAPTURE_TOOL_NAMES = {"create_note", "create_task", "create_event", "update_note", "research_topic"}
+_CAPTURE_TOOL_NAMES = {"create_note", "create_event", "update_note", "research_topic"}
 
 _SYSTEM_PROMPT = """\
 Today is {today}. You are a quick-capture assistant. The user has sent a short \
@@ -53,11 +52,10 @@ async def quick_capture_route():
         {"role": "user", "content": text},
     ]
 
-    think = _should_think(text, think_requested=True)
-
+    # Quick capture is a fast classification path — never think.
     tool_calls: list[dict] = []
     try:
-        async for chunk in stream_chat_with_tools(messages, model, tools=capture_tools, think=think, num_ctx=4096):
+        async for chunk in stream_chat_with_tools(messages, model, tools=capture_tools, think=False, num_ctx=4096):
             if chunk.type == "tool_calls" and chunk.tool_calls:
                 tool_calls = chunk.tool_calls
     except Exception:

src/fabledassistant/routes/settings.py

@@ -16,6 +16,7 @@ async def _prime_kv_cache_bg(user_id: int, model: str) -> None:
     """Fire-and-forget: prime Ollama's KV cache with the user's system prompt."""
     import httpx
     from fabledassistant.services.llm import build_context, pick_num_ctx
+    from fabledassistant.services.tools import get_tools_for_user
     try:
         messages, _ = await build_context(
             user_id=user_id,
@@ -23,7 +24,12 @@ async def _prime_kv_cache_bg(user_id: int, model: str) -> None:
             current_note_id=None,
             user_message=" ",
         )
-        num_ctx = pick_num_ctx(messages)
+        # Size the prime to match what real chat requests will use, including
+        # tool schemas — otherwise Ollama reloads the model on the first real
+        # request and throws away the cache we just built.
+        tools = await get_tools_for_user(user_id)
+        num_ctx = pick_num_ctx(messages, tools=tools)
+        from fabledassistant.services.llm import keep_alive_for
         async with httpx.AsyncClient(timeout=120.0) as client:
             await client.post(
                 f"{Config.OLLAMA_URL}/api/chat",
@@ -32,7 +38,7 @@ async def _prime_kv_cache_bg(user_id: int, model: str) -> None:
                     "messages": messages,
                     "stream": False,
                     "options": {"num_predict": 1, "num_ctx": num_ctx},
-                    "keep_alive": "2h",
+                    "keep_alive": keep_alive_for(model),
                 },
             )
         logger.info("Primed KV cache for user %d with model '%s' (num_ctx=%d)", user_id, model, num_ctx)
@@ -58,6 +64,15 @@ async def update_settings_route():
     if not isinstance(data, dict):
         return jsonify({"error": "Expected a JSON object"}), 400
 
+    # Normalize model names to lowercase before validation. Ollama's /api/tags
+    # preserves whatever casing was used at pull time, but /api/chat rejects
+    # mixed-case tags — lowercasing here keeps the two paths consistent and
+    # means the stored setting is always in a form Ollama will actually accept.
+    _MODEL_KEYS = frozenset({"default_model", "background_model"})
+    for _key in _MODEL_KEYS:
+        if _key in data and data[_key]:
+            data[_key] = str(data[_key]).lower()
+
     if "default_model" in data:
         installed = await get_installed_models()
         if data["default_model"]:
@@ -68,7 +83,6 @@ async def update_settings_route():
     # Empty string for model keys means "reset to system default".
     # Delete the DB row so get_setting() falls back to Config defaults
     # rather than returning "" and breaking model resolution everywhere.
-    _MODEL_KEYS = frozenset({"default_model", "background_model"})
     to_save = {}
     for k, v in data.items():
         str_v = str(v)

src/fabledassistant/services/article_context.py

@@ -0,0 +1,270 @@
+"""Prepare article bodies as conversation-ready context.
+
+Used by the briefing ``discuss-article`` flow and the ``/news`` discuss button.
+A raw trafilatura extraction is often too large to drop whole into a chat
+history without eating the context window, so this module runs a map-reduce
+step over oversized articles and returns a compact, structured context that
+still preserves the article's meaning across sections.
+
+Small articles pass through unchanged — map-reduce only fires when the raw
+body exceeds CHAR_BUDGET. The output is cached on ``rss_items.context_prepared``
+by the caller, so repeat discuss-clicks on the same article skip this work
+entirely.
+
+The module also owns ``seed_article_discussion``, the shared routine that
+stages a synthetic ``read_article`` tool exchange plus a conversational seed
+prompt into a conversation. Both the briefing and ``/news`` entry points call
+it so the two flows stay byte-identical — the only thing that differs between
+them is whether the conversation already existed or was freshly created.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+
+from fabledassistant.models import async_session
+from fabledassistant.models.rss_feed import RssItem
+from fabledassistant.services.chat import add_message
+from fabledassistant.services.llm import generate_completion
+
+logger = logging.getLogger(__name__)
+
+# ~12k tokens at 4 chars/token. Comfortably under OLLAMA_NUM_CTX=16384
+# with room left for system prompt, chat history, and the assistant reply.
+CHAR_BUDGET = 48_000
+
+# Chunk size for the map step on oversized articles. Overlap preserves
+# context across paragraph boundaries that happen to land mid-sentence.
+CHUNK_CHARS = 8_000
+CHUNK_OVERLAP = 400
+
+_PARA_SPLIT = re.compile(r"\n\s*\n")
+
+
+def _chunk_by_paragraph(body: str) -> list[str]:
+    """Split ``body`` into chunks of up to CHUNK_CHARS, respecting paragraphs.
+
+    Paragraphs longer than CHUNK_CHARS are split mid-paragraph as a last
+    resort. Adjacent chunks share CHUNK_OVERLAP chars of trailing text so
+    a sentence straddling the boundary stays readable on both sides.
+    """
+    paragraphs = [p.strip() for p in _PARA_SPLIT.split(body) if p.strip()]
+    chunks: list[str] = []
+    current: list[str] = []
+    current_len = 0
+    for para in paragraphs:
+        para_len = len(para)
+        if para_len > CHUNK_CHARS:
+            if current:
+                chunks.append("\n\n".join(current))
+                current, current_len = [], 0
+            for i in range(0, para_len, CHUNK_CHARS - CHUNK_OVERLAP):
+                chunks.append(para[i : i + CHUNK_CHARS])
+            continue
+        if current_len + para_len + 2 > CHUNK_CHARS and current:
+            chunks.append("\n\n".join(current))
+            tail = current[-1][-CHUNK_OVERLAP:] if current else ""
+            current = [tail, para] if tail else [para]
+            current_len = len(tail) + para_len + (2 if tail else 0)
+        else:
+            current.append(para)
+            current_len += para_len + 2
+    if current:
+        chunks.append("\n\n".join(current))
+    return chunks
+
+
+async def _summarize_chunk(title: str, chunk: str, index: int, total: int, model: str) -> str:
+    """Map-step summary of one article chunk.
+
+    Aims for ~300 words of dense, factual prose — not bullet points — so the
+    downstream chat model can quote from it naturally.
+    """
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are summarizing one section of a larger article so a downstream "
+                "conversation model can discuss the full article without having to read "
+                "every word.\n\n"
+                "Requirements:\n"
+                "- 250–350 words of dense factual prose\n"
+                "- Preserve specific claims, numbers, names, and quotes\n"
+                "- Do NOT editorialize or add analysis\n"
+                "- Do NOT use bullet points or headings\n"
+                "- Do NOT say 'this section' or 'this article' — write content, not meta"
+            ),
+        },
+        {
+            "role": "user",
+            "content": (
+                f"Article: {title}\n"
+                f"Section {index + 1} of {total}:\n\n{chunk}"
+            ),
+        },
+    ]
+    try:
+        # Pin num_ctx — same rationale as services/research.py:66. A large
+        # chunk plus system prompt can push well past the default window;
+        # silent truncation here would drop the tail of the chunk without
+        # any error, producing a misleading summary.
+        raw = await generate_completion(
+            messages, model, max_tokens=600, num_ctx=16384
+        )
+        return raw.strip()
+    except Exception:
+        logger.warning(
+            "Article chunk summary failed for section %d/%d of '%s'",
+            index + 1, total, title, exc_info=True,
+        )
+        # Fall back to the raw chunk truncated to ~1500 chars so the overall
+        # pipeline still delivers something rather than dropping the section.
+        return chunk[:1500]
+
+
+async def prepare_article_context(
+    title: str,
+    url: str,
+    body: str,
+    model: str,
+) -> str:
+    """Return a conversation-ready context block for ``body``.
+
+    - Small article (≤ CHAR_BUDGET): returns ``body`` unchanged.
+    - Oversized article: runs a parallel map step over paragraph-aware
+      chunks and concatenates the summaries under section headers.
+
+    The returned string is what should go into the ``read_article`` synthetic
+    tool-result in chat history. Callers are responsible for caching it to
+    ``rss_items.context_prepared``.
+    """
+    body = body or ""
+    if len(body) <= CHAR_BUDGET:
+        return body
+
+    chunks = _chunk_by_paragraph(body)
+    logger.info(
+        "Article '%s' is %d chars, map-reducing into %d chunks",
+        title, len(body), len(chunks),
+    )
+
+    summaries = await asyncio.gather(
+        *[
+            _summarize_chunk(title, chunk, i, len(chunks), model)
+            for i, chunk in enumerate(chunks)
+        ]
+    )
+
+    header = (
+        f"(This article was longer than the chat window could hold verbatim, "
+        f"so the full text was split into {len(chunks)} sections and each was "
+        "summarized below. Each section preserves specific claims, numbers, "
+        "and quotes from the original.)\n\n"
+    )
+    parts = [
+        f"## Section {i + 1}\n\n{summary}"
+        for i, summary in enumerate(summaries)
+    ]
+    return header + "\n\n".join(parts)
+
+
+# Conversational seed prompt for article discussions. Kept here so both the
+# briefing and /news entry points use the exact same wording. See
+# feedback_discuss_prompt_style memory: numbered checklists produce
+# assignment-completion responses; this conversational seed opens a dialogue.
+ARTICLE_DISCUSS_SEED = (
+    "I want to talk about this article. Start with a substantive summary "
+    "of what it's arguing and the key evidence it uses, then tell me what "
+    "stood out to you or seems worth pushing back on. I'll ask follow-ups "
+    "from there."
+)
+
+
+class EmptyArticleError(Exception):
+    """Raised when an article has no extractable body text.
+
+    Callers (the briefing and /news discuss routes) map this to a 422 so the
+    user sees a clear error instead of a hallucinated summary built from an
+    empty synthetic tool result.
+    """
+
+
+async def seed_article_discussion(
+    conv_id: int,
+    item: RssItem,
+    model: str,
+) -> str:
+    """Stage the synthetic read_article tool exchange + conversational seed.
+
+    Used by both the briefing ``discuss_article`` route and the ``/news``
+    ``from-article`` conversation creator. Handles the three-layer cache
+    (``context_prepared`` → ``content_full`` → fresh fetch) and inserts two
+    messages into ``conv_id``:
+
+    1. An assistant message with a synthetic ``read_article`` tool_call whose
+       ``result.content`` carries the prepared article context. The message
+       also carries ``msg_metadata={"rss_item_id": ...}`` so the post-generation
+       hook in ``generation_task.py`` can locate it and persist the first
+       reply as a discussion-summary Note.
+    2. A user message with the shared conversational seed prompt.
+
+    Returns the seed prompt string so callers can pass it to ``run_generation``
+    as ``user_content``.
+    """
+    # Avoid circulars: rss helper imports article_context indirectly nowhere,
+    # but keep this local for symmetry with the route-level imports it
+    # replaces.
+    from fabledassistant.services.rss import get_or_fetch_full_article
+
+    if item.context_prepared:
+        article_content = item.context_prepared
+    else:
+        raw_body = await get_or_fetch_full_article(item) or item.content or ""
+        if not raw_body.strip():
+            # Hard-fail rather than stage an empty synthetic tool result.
+            # An empty `content` field silently tells the model "the article
+            # has nothing in it" and it confabulates from RAG/history. Better
+            # to surface a clean error to the user.
+            logger.warning(
+                "Article discussion aborted: empty body for rss_item %s (%s)",
+                item.id, item.url,
+            )
+            raise EmptyArticleError(
+                "Couldn't extract any readable text from this article."
+            )
+        article_content = await prepare_article_context(
+            item.title or "", item.url, raw_body, model,
+        )
+        if not article_content.strip():
+            raise EmptyArticleError(
+                "Couldn't extract any readable text from this article."
+            )
+        async with async_session() as session:
+            fresh = await session.get(RssItem, item.id)
+            if fresh is not None:
+                fresh.context_prepared = article_content
+                await session.commit()
+
+    synthetic_tool_calls = [{
+        "function": "read_article",
+        "arguments": {"url": item.url},
+        "result": {
+            "success": True,
+            "type": "article_content",
+            "url": item.url,
+            "content": article_content,
+            "truncated": False,
+        },
+    }]
+    await add_message(
+        conv_id,
+        "assistant",
+        "",
+        status="complete",
+        tool_calls=synthetic_tool_calls,
+        msg_metadata={"rss_item_id": item.id, "article_seed": True},
+    )
+    await add_message(conv_id, "user", ARTICLE_DISCUSS_SEED)
+    return ARTICLE_DISCUSS_SEED

src/fabledassistant/services/briefing_conversations.py

@@ -1,12 +1,13 @@
 """Create and manage briefing conversations."""
 
 import logging
-from datetime import date, datetime, timezone
+from datetime import datetime, timezone
 
 from sqlalchemy import select
 
 from fabledassistant.models import async_session
 from fabledassistant.models.conversation import Conversation, Message
+from fabledassistant.services.tz import user_briefing_date
 
 logger = logging.getLogger(__name__)
 
@@ -15,7 +16,10 @@ async def get_or_create_today_conversation(user_id: int, model: str) -> Conversa
     """
     Return today's briefing conversation, creating it if it doesn't exist.
     """
-    today = date.today()
+    # "Today" is the user-local briefing day (flips at 4am local), not
+    # ``date.today()`` — in a UTC container the latter rolls over at
+    # 19:00 NY local and makes the in-progress briefing disappear.
+    today = await user_briefing_date(user_id)
     async with async_session() as session:
         result = await session.execute(
             select(Conversation).where(
@@ -46,8 +50,15 @@ async def post_message(
     role: str,
     content: str,
     metadata: dict | None = None,
+    tool_calls: list | None = None,
 ) -> Message:
-    """Append a message to a briefing conversation."""
+    """Append a message to a briefing conversation.
+
+    ``tool_calls`` is accepted on assistant-role messages so the full
+    agentic briefing sequence (assistant tool-call turns and tool-role
+    results) can be persisted as real conversation rows, keeping the
+    receipts in context on chat follow-ups.
+    """
     async with async_session() as session:
         msg = Message(
             conversation_id=conversation_id,
@@ -55,6 +66,7 @@ async def post_message(
             content=content,
             status="complete",
             msg_metadata=metadata,
+            tool_calls=tool_calls,
         )
         session.add(msg)
         # Bump conversation updated_at

src/fabledassistant/services/briefing_pipeline.py

@@ -1,19 +1,14 @@
 """
-Briefing pipeline: parallel data gather + two-lane LLM synthesis.
+Briefing pipeline: agentic tool-use loop + UI metadata gather.
 
 Slot names: 'compilation' (4am), 'morning' (8am), 'midday' (12pm), 'afternoon' (4pm)
 """
 
 import asyncio
-import hashlib
 import logging
-from datetime import datetime, timezone
+from datetime import datetime
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
-import httpx
-
-from fabledassistant.models import async_session
-
 from fabledassistant.config import Config
 from fabledassistant.services.settings import get_setting
 
@@ -22,320 +17,298 @@ logger = logging.getLogger(__name__)
 SLOT_NAMES = ("compilation", "morning", "midday", "afternoon")
 
 
+# ── External data gather ──────────────────────────────────────────────────────
 
-def format_task(task: dict) -> str:
-    parts = [task.get("title", "Untitled")]
-    if task.get("status"):
-        parts.append(f"[{task['status'].replace('_', ' ').title()}]")
-    if task.get("due_date"):
-        parts.append(f"due {task['due_date']}")
-    if task.get("priority") and task["priority"] not in ("none", ""):
-        parts.append(f"priority: {task['priority']}")
-    return " — ".join(parts)
+async def _gather_external(user_id: int) -> dict:
+    """Collect RSS items (when enabled) and weather."""
+    from fabledassistant.services.weather import get_cached_weather
+
+    rss_on = (await get_setting(user_id, "rss_enabled", "false")).lower() == "true"
+    rss_items: list = []
+    if rss_on:
+        from fabledassistant.services.rss import get_recent_items
+        try:
+            rss_items = await get_recent_items(user_id, limit=20)
+        except Exception:
+            pass
+
+    try:
+        weather = await get_cached_weather(user_id)
+    except Exception:
+        weather = []
+
+    return {
+        "rss_items": rss_items,
+        "weather": weather,
+    }
 
 
-def compute_task_hash(task: dict) -> str:
-    """Stable SHA-256 of the task's key change-detectable fields."""
-    key = "|".join([
-        str(task.get("status") or ""),
-        str(task.get("priority") or ""),
-        str(task.get("due_date") or ""),
-        str(task.get("title") or ""),
-    ])
-    return hashlib.sha256(key.encode()).hexdigest()
+# ── Agentic briefing (tool-use loop) ──────────────────────────────────────────
+
+_BRIEFING_AGENT_MAX_ROUNDS = 8
+_BRIEFING_AGENT_NUM_CTX = 8192
 
 
-async def split_changed_tasks(
-    user_id: int,
-    tasks: list[dict],
-) -> tuple[list[dict], int]:
+def _agentic_system_prompt(
+    profile_body: str,
+    slot: str,
+    today_iso: str,
+    tz_name: str,
+    day_from_iso: str,
+    day_to_iso: str,
+) -> str:
+    """System prompt for the agentic briefing path.
+
+    Pushes the model to ground every factual claim in a tool result and
+    to be honest when tools return nothing, rather than fabricating
+    content to fill the narrative.
+
+    Pre-computes today's window in the user's local timezone so the
+    model can call date-sensitive tools (list_events, list_tasks filters)
+    without having to do any timezone math itself — eliminating a whole
+    class of "wrong day" bugs.
     """
-    Compare tasks against the briefing_task_snapshot table.
-    Returns (changed_tasks, unchanged_count).
-    changed_tasks includes new tasks (no snapshot row) and tasks whose hash differs.
-    """
-    from sqlalchemy import text
+    tz_block = (
+        f"Today is {today_iso} ({tz_name}). "
+        f"When calling list_events for today, use:\n"
+        f"  date_from = {day_from_iso}\n"
+        f"  date_to   = {day_to_iso}\n"
+        f"These are already the correct local-day boundaries — do not convert "
+        f"them to UTC or any other timezone. For other date ranges, compute in "
+        f"the same timezone.\n\n"
+    )
 
-    if not tasks:
-        return [], 0
-
-    task_ids = [t["task_id"] for t in tasks if t.get("task_id")]
-
-    async with async_session() as session:
-        result = await session.execute(
-            text("""
-                SELECT task_id, snapshot_hash
-                FROM briefing_task_snapshot
-                WHERE user_id = :uid AND task_id = ANY(:ids)
-            """).bindparams(uid=user_id, ids=task_ids)
+    if slot == "compilation":
+        base = (
+            "You are the user's personal assistant giving their full morning briefing. "
+            "Weave real data from tool calls into a warm, natural-sounding summary.\n\n"
+            "Tools to call every compilation (skip only if you already know a category is empty):\n"
+            "- list_tasks — what's due today, overdue, or in progress\n"
+            "- list_events — what's on the calendar today\n"
+            "- get_weather — today's forecast\n"
+            "- get_rss_items — recent news/blog items from the user's feeds\n"
+            "- list_projects (optional) — active project context for narrative continuity\n\n"
+            "Rules:\n"
+            "- Call tools to see the data. Never assert facts you didn't learn from a tool.\n"
+            "- If a tool returns nothing (no events today, no overdue tasks, no news items), "
+            "say so honestly. Don't fabricate items to fill space.\n"
+            "- For news, pick one or two items worth mentioning — surface the theme, not a laundry list.\n"
+            "- Write flowing prose. No markdown, no headers, no bullet points.\n"
+            "- Aim for 6 to 10 sentences. Skip topics that have nothing interesting.\n"
+            "- Close on one or two concrete, actionable suggestions.\n\n"
+        )
+    elif slot == "weekly_review":
+        base = (
+            "You are the user's personal assistant delivering a weekly review. "
+            "Use the tools available to see what was accomplished this week, what's still "
+            "overdue, how many notes were captured, and what's coming up in the next seven days. "
+            "Write a reflective recap that celebrates real progress and gently flags what's stuck.\n\n"
+            "Rules:\n"
+            "- Call tools to see the data. Never assert facts you didn't learn from a tool.\n"
+            "- If a category is empty, say so honestly rather than inventing items.\n"
+            "- Write flowing prose. No markdown, no bullet points.\n"
+            "- Aim for 5 to 8 sentences. Reflective and encouraging tone.\n\n"
+        )
+    else:  # morning, midday, afternoon check-ins
+        base = (
+            f"You are the user's personal assistant giving a brief {slot} check-in. "
+            "Use tools to see what's changed since this morning. Focus on progress and "
+            "what's still unaddressed.\n\n"
+            "When checking tasks, call list_tasks at least twice:\n"
+            "- once with status=\"in_progress\" to see anything already being worked on "
+            "(regardless of due date — these can quietly drag past their due dates)\n"
+            "- once filtered by due date for what's coming up or overdue today\n\n"
+            "Rules:\n"
+            "- Call tools to see current state. Never assert facts without tool results.\n"
+            "- If nothing meaningful has changed, say so briefly — don't invent progress.\n"
+            "- 3 to 5 sentences, natural prose, no markdown.\n\n"
         )
-        snapshots = {row.task_id: row.snapshot_hash for row in result}
 
-    changed = []
-    unchanged_count = 0
-    for task in tasks:
-        current_hash = compute_task_hash(task)
-        stored_hash = snapshots.get(task.get("task_id"))
-        if stored_hash is None or stored_hash != current_hash:
-            changed.append(task)
-        else:
-            unchanged_count += 1
-
-    return changed, unchanged_count
+    base = tz_block + base
+    if profile_body:
+        base += f"User profile (tone and preferences):\n{profile_body}\n"
+    return base
 
 
-async def upsert_task_snapshots(user_id: int, tasks: list[dict]) -> None:
-    """Upsert snapshot hashes for all tasks included in this briefing."""
-    from sqlalchemy import text
-
-    if not tasks:
-        return
-
-    now = datetime.now(timezone.utc)
-    async with async_session() as session:
-        for task in tasks:
-            task_id = task.get("task_id")
-            if not task_id:
-                continue
-            await session.execute(
-                text("""
-                    INSERT INTO briefing_task_snapshot (user_id, task_id, snapshot_hash, last_briefed)
-                    VALUES (:uid, :tid, :hash, :now)
-                    ON CONFLICT (user_id, task_id)
-                    DO UPDATE SET snapshot_hash = EXCLUDED.snapshot_hash,
-                                  last_briefed = EXCLUDED.last_briefed
-                """).bindparams(
-                    uid=user_id,
-                    tid=task_id,
-                    hash=compute_task_hash(task),
-                    now=now,
-                )
-            )
-        await session.commit()
+def _agentic_user_trigger(slot: str, date_str: str) -> str:
+    """Seed user-role message that kicks off the agentic run."""
+    labels = {
+        "compilation": "morning briefing",
+        "morning": "morning check-in",
+        "midday": "midday check-in",
+        "afternoon": "afternoon wrap-up",
+        "weekly_review": "weekly review",
+    }
+    label = labels.get(slot, f"{slot} briefing")
+    return f"Generate my {label} for {date_str}."
 
 
-# ── Internal data gather ──────────────────────────────────────────────────────
+async def run_agentic_briefing(
+    user_id: int,
+    slot: str,
+    model: str,
+    conv_id: int | None = None,
+    rss_override: list[dict] | None = None,
+) -> tuple[str, list[dict]]:
+    """
+    Run the agentic briefing loop for a user and slot.
 
-async def _gather_internal(user_id: int) -> dict:
-    """Collect tasks, calendar events, and project data."""
-    from fabledassistant.services.notes import list_notes
-    from fabledassistant.services.projects import list_projects
-    from fabledassistant.services.caldav import is_caldav_configured, list_events
+    Uses the chat pipeline's tool-use loop with a curated read-only tool
+    subset and a slot-specific system prompt. Every fact the model states
+    is either derived from a tool result visible in the returned message
+    list or it's the model hallucinating — so follow-up chat in the same
+    conversation can hold the model to what the tool results actually show.
 
+    Returns ``(final_prose, message_list)`` where ``message_list`` is the
+    full sequence including system, user trigger, tool calls, and tool
+    results. Callers are expected to persist those intermediate turns
+    alongside the final prose so the receipts remain in conversation
+    history on follow-up.
+
+    If the loop fails or the model returns empty prose, returns
+    ``("", [])`` and the caller should fall back to the legacy path.
+    """
+    from fabledassistant.services.llm import stream_chat_with_tools, ChatChunk  # noqa: F401
+    from fabledassistant.services.tools import execute_tool
+    from fabledassistant.services.briefing_tools import get_briefing_tools
+    from fabledassistant.services.user_profile import build_profile_context
+
+    profile_context = await build_profile_context(user_id)
+    tools = await get_briefing_tools(user_id)
+
+    if not tools:
+        logger.warning(
+            "Agentic briefing for user %d slot %s: no tools available — aborting",
+            user_id, slot,
+        )
+        return "", []
+
+    # Compute today's window in the user's local timezone so the model
+    # receives ready-to-use ISO 8601 boundaries and never has to do its
+    # own tz math when calling date-sensitive tools like list_events.
     tz_name = await get_setting(user_id, "user_timezone") or "UTC"
     try:
         user_tz = ZoneInfo(tz_name)
     except ZoneInfoNotFoundError:
         user_tz = ZoneInfo("UTC")
+        tz_name = "UTC"
+    now_local = datetime.now(user_tz)
+    today_iso = now_local.date().isoformat()
+    day_start = datetime(now_local.year, now_local.month, now_local.day, 0, 0, 0, tzinfo=user_tz)
+    day_end = datetime(now_local.year, now_local.month, now_local.day, 23, 59, 59, tzinfo=user_tz)
+    day_from_iso = day_start.isoformat()
+    day_to_iso = day_end.isoformat()
 
-    today = datetime.now(user_tz).date().isoformat()
-
-    # Tasks: overdue, due today, high priority in-progress
-    all_tasks: list[dict] = []
-    try:
-        all_task_objs, _total = await list_notes(user_id, is_task=True, limit=100)
-        all_tasks = [
-            {
-                "task_id": t.id,
-                "title": t.title,
-                "status": t.status,
-                "due_date": t.due_date.isoformat() if t.due_date else None,
-                "priority": t.priority,
-            }
-            for t in all_task_objs
-        ]
-        overdue = [
-            format_task(t) for t in all_tasks
-            if t.get("due_date") and t["due_date"] < today and t.get("status") != "done"
-        ]
-        due_today = [
-            format_task(t) for t in all_tasks
-            if t.get("due_date") == today and t.get("status") != "done"
-        ]
-        high_priority = [
-            format_task(t) for t in all_tasks
-            if t.get("priority") == "high" and t.get("status") not in ("done",) and
-               format_task(t) not in overdue and format_task(t) not in due_today
-        ][:5]
-    except Exception:
-        logger.warning("Failed to gather tasks for briefing", exc_info=True)
-        overdue, due_today, high_priority = [], [], []
-
-    # Calendar events today — internal store
-    calendar_events: list[str] = []
-    try:
-        from fabledassistant.services.events import list_events as list_internal_events
-        today_date = datetime.now(user_tz).date()
-        day_start = datetime(today_date.year, today_date.month, today_date.day, 0, 0, 0, tzinfo=user_tz)
-        day_end = datetime(today_date.year, today_date.month, today_date.day, 23, 59, 59, tzinfo=user_tz)
-        internal_events = await list_internal_events(
-            user_id=user_id, date_from=day_start, date_to=day_end
-        )
-        for e in internal_events:
-            if e.get("all_day"):
-                time_str = "all day"
-            elif e.get("start_dt"):
-                from datetime import datetime as _dt
-                start = e["start_dt"]
-                if isinstance(start, str):
-                    start = _dt.fromisoformat(start)
-                local_dt = start.astimezone(user_tz) if start.tzinfo else start.replace(tzinfo=timezone.utc).astimezone(user_tz)
-                time_str = local_dt.strftime("%-I:%M %p")
-            else:
-                time_str = "unknown time"
-            calendar_events.append(f"{e.get('title', 'Event')} at {time_str}")
-    except Exception:
-        logger.warning("Failed to gather internal calendar events for briefing", exc_info=True)
-    # Also pull CalDAV events (deduped)
-    try:
-        if await is_caldav_configured(user_id):
-            caldav_evs = await list_events(user_id, start=today, end=today)
-            for e in (caldav_evs or []):
-                summary = f"{e.get('summary', 'Event')} at {e.get('dtstart', 'unknown time')}"
-                if summary not in calendar_events:
-                    calendar_events.append(summary)
-    except Exception:
-        logger.warning("Failed to gather CalDAV calendar events for briefing", exc_info=True)
-
-    # Projects: active projects
-    projects_summary = []
-    try:
-        projects = await list_projects(user_id)
-        for p in projects[:5]:
-            projects_summary.append(p.title or "Untitled project")
-    except Exception:
-        logger.warning("Failed to gather projects for briefing", exc_info=True)
-
-    return {
-        "date": today,
-        "overdue_tasks": overdue,
-        "due_today": due_today,
-        "high_priority": high_priority,
-        "calendar_events": calendar_events,
-        "active_projects": projects_summary,
-        "all_tasks_raw": all_tasks,
-    }
-
-
-# ── External data gather ──────────────────────────────────────────────────────
-
-async def _gather_external(user_id: int) -> dict:
-    """Collect RSS items and weather."""
-    from fabledassistant.services.rss import get_recent_items
-    from fabledassistant.services.weather import get_cached_weather
-
-    rss_items, weather = await asyncio.gather(
-        get_recent_items(user_id, limit=20),
-        get_cached_weather(user_id),
-        return_exceptions=True,
+    system_prompt = _agentic_system_prompt(
+        profile_context, slot, today_iso, tz_name, day_from_iso, day_to_iso,
     )
-    return {
-        "rss_items": rss_items if not isinstance(rss_items, Exception) else [],
-        "weather": weather if not isinstance(weather, Exception) else [],
-    }
+    messages: list[dict] = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": _agentic_user_trigger(slot, today_iso)},
+    ]
 
+    final_text = ""
+    for round_idx in range(_BRIEFING_AGENT_MAX_ROUNDS):
+        accumulated_content = ""
+        accumulated_tool_calls: list[dict] = []
 
-# ── LLM synthesis ─────────────────────────────────────────────────────────────
-
-async def _llm_synthesise(system_prompt: str, user_prompt: str, model: str, num_ctx: int = 4096) -> str:
-    """Single non-streaming LLM call. Returns the assistant's response text."""
-    payload = {
-        "model": model,
-        "messages": [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ],
-        "stream": False,
-        "options": {"num_ctx": num_ctx, "temperature": 0.4},
-    }
-    try:
-        async with httpx.AsyncClient(timeout=120.0) as client:
-            resp = await client.post(f"{Config.OLLAMA_URL}/api/chat", json=payload)
-            resp.raise_for_status()
-            data = resp.json()
-            return data.get("message", {}).get("content", "").strip()
-    except Exception:
-        logger.warning("LLM synthesis failed", exc_info=True)
-        return ""
-
-
-def _unified_system_prompt(profile_body: str) -> str:
-    return (
-        "You are a personal assistant delivering a daily briefing. "
-        "Speak naturally and conversationally — as if talking to the user, not writing a report. "
-        "Use no markdown: no headers, no bullet points, no bold, no lists. Write in flowing prose. "
-        "Weave together what matters today: mention the weather in a sentence, note any calendar "
-        "events or tasks due today, and briefly reference one or two noteworthy news stories. "
-        "Only mention projects if a task from one is specifically due today. "
-        "Be warm, concise, and human — aim for 3 to 5 sentences. "
-        "Future context like emails and messages will be added over time — keep the tone open and helpful.\n\n"
-        + (f"User profile:\n{profile_body}\n" if profile_body else "")
-    )
-
-
-def _unified_user_prompt(internal_data: dict, external_data: dict, slot: str, temp_unit: str = "C") -> str:
-    lines = [f"Date: {internal_data['date']}", f"Slot: {slot}", ""]
-
-    # Weather (brief — card handles detail)
-    weather = external_data.get("weather") or []
-    if weather:
-        loc = weather[0]
-        days = loc.get("days") or []
-        if days:
-            d = days[0]
-            t_min = _format_temp(d["temp_min"], temp_unit)
-            t_max = _format_temp(d["temp_max"], temp_unit)
-            unit_sym = f"°{temp_unit}"
-            lines.append(
-                f"WEATHER: {loc['location_label']} — {d['description']}, "
-                f"{t_min}–{t_max}{unit_sym}"
+        try:
+            async for chunk in stream_chat_with_tools(
+                messages, model, tools=tools, think=False,
+                num_ctx=_BRIEFING_AGENT_NUM_CTX,
+            ):
+                if chunk.type == "content" and chunk.content:
+                    accumulated_content += chunk.content
+                elif chunk.type == "tool_calls" and chunk.tool_calls:
+                    accumulated_tool_calls.extend(chunk.tool_calls)
+        except Exception:
+            logger.warning(
+                "Agentic briefing stream failed (user %d, slot %s, round %d)",
+                user_id, slot, round_idx, exc_info=True,
             )
-            lines.append("")
+            return "", []
 
-    # Today's calendar events
-    if internal_data.get("calendar_events"):
-        lines.append("TODAY'S EVENTS:")
-        lines.extend(f"  - {e}" for e in internal_data["calendar_events"])
-        lines.append("")
+        # Append the assistant turn (content + any tool calls) to history
+        assistant_msg: dict = {"role": "assistant", "content": accumulated_content}
+        if accumulated_tool_calls:
+            assistant_msg["tool_calls"] = accumulated_tool_calls
+        messages.append(assistant_msg)
 
-    # Tasks due today
-    if internal_data.get("due_today"):
-        lines.append("DUE TODAY:")
-        lines.extend(f"  - {t}" for t in internal_data["due_today"])
-        lines.append("")
+        # No tool calls → the model is done
+        if not accumulated_tool_calls:
+            final_text = accumulated_content.strip()
+            break
 
-    # Overdue tasks (brief mention only)
-    if internal_data.get("overdue_tasks"):
-        overdue = internal_data["overdue_tasks"]
-        lines.append(f"OVERDUE ({len(overdue)} task{'s' if len(overdue) != 1 else ''}):")
-        lines.extend(f"  - {t}" for t in overdue[:3])
-        if len(overdue) > 3:
-            lines.append(f"  (and {len(overdue) - 3} more)")
-        lines.append("")
+        # Execute each tool call and append results as tool-role messages
+        for tc in accumulated_tool_calls:
+            fn = tc.get("function") or {}
+            tool_name = fn.get("name", "")
+            arguments = fn.get("arguments") or {}
+            if isinstance(arguments, str):
+                try:
+                    import json as _json
+                    arguments = _json.loads(arguments)
+                except Exception:
+                    arguments = {}
 
-    # News highlights (top 3 with excerpts — right panel shows full list)
-    rss = external_data.get("rss_items") or []
-    if rss:
-        lines.append("NEWS HIGHLIGHTS (weave 1-2 into your briefing naturally; the full list is shown separately):")
-        for item in rss[:3]:
-            source = item.get("feed_title") or item.get("source") or "News"
-            title = item.get("title", "")
-            excerpt = (item.get("content") or item.get("snippet") or "")[:500].strip()
-            lines.append(f"  [{source}] {title}")
-            if excerpt:
-                lines.append(f"    {excerpt}")
-        lines.append("")
+            # Default list_tasks to active statuses only so cancelled/done
+            # items don't slip into briefing prose. The model can still
+            # pass an explicit status filter when it wants something else.
+            if tool_name == "list_tasks" and not arguments.get("status"):
+                arguments["status"] = ["todo", "in_progress"]
 
-    return "\n".join(lines)
+            try:
+                if tool_name == "get_rss_items" and rss_override is not None:
+                    # Use topic-scored/filtered items already computed by
+                    # the briefing pipeline rather than the raw feed dump
+                    # that execute_tool would return. Keeps the model's
+                    # view of news aligned with the user's topic prefs
+                    # and the sidebar's rss_item_ids metadata.
+                    slim = [
+                        {
+                            "id": item.get("id"),
+                            "title": item.get("title", ""),
+                            "url": item.get("url", ""),
+                            "source": item.get("feed_title", ""),
+                            "summary": (item.get("content") or "")[:400],
+                            "published_at": item.get("published_at"),
+                            "topics": item.get("topics") or [],
+                        }
+                        for item in rss_override
+                    ]
+                    result = {"success": True, "data": {"items": slim, "count": len(slim)}}
+                else:
+                    result = await execute_tool(user_id, tool_name, arguments, conv_id=conv_id)
+            except Exception as exc:
+                logger.warning(
+                    "Tool %s failed during agentic briefing: %s", tool_name, exc,
+                )
+                result = {"success": False, "error": str(exc)}
 
+            # Serialize the result compactly for the model's context
+            import json as _json
+            try:
+                result_str = _json.dumps(result, default=str)[:4000]
+            except Exception:
+                result_str = str(result)[:4000]
 
-def _format_temp(value: float, unit: str) -> str:
-    """Convert Celsius to the requested unit and format as an integer string."""
-    if unit == "F":
-        return f"{value * 9 / 5 + 32:.0f}"
-    return f"{value:.0f}"
-
+            messages.append({
+                "role": "tool",
+                "content": result_str,
+                "tool_name": tool_name,
+            })
+    else:
+        logger.warning(
+            "Agentic briefing hit max rounds (%d) for user %d slot %s — using last content",
+            _BRIEFING_AGENT_MAX_ROUNDS, user_id, slot,
+        )
+        # Walk back to find the last assistant message with non-empty content
+        for m in reversed(messages):
+            if m.get("role") == "assistant" and m.get("content"):
+                final_text = m["content"].strip()
+                break
 
+    return final_text, messages
 
 
 # ── Main entry point ───────────────────────────────────────────────────────────
@@ -358,14 +331,16 @@ async def run_compilation(
     model: str | None = None,
 ) -> tuple[str, dict]:
     """
-    Run the full two-lane briefing pipeline for a user and slot.
-    Returns (briefing_text, metadata_dict) where metadata contains
-    weather card data and rss_item_ids for frontend rendering.
+    Run the agentic briefing loop and gather UI metadata (RSS + weather).
+
+    Returns ``(briefing_text, metadata)`` where metadata contains
+    ``rss_item_ids``, ``rss_items``, ``weather`` for frontend rendering,
+    and ``agentic_messages`` (the full tool-call sequence) for the
+    scheduler to persist as separate conversation rows.
     """
     if model is None:
         model = await get_setting(user_id, "default_model", Config.OLLAMA_MODEL)
 
-    from fabledassistant.services.user_profile import build_profile_context
     from fabledassistant.services.briefing_preferences import (
         load_topic_preferences,
         load_topic_reaction_scores,
@@ -373,27 +348,15 @@ async def run_compilation(
     )
     from fabledassistant.services.weather import parse_weather_card_data, get_cached_weather_rows
 
-    profile_context, temp_unit = await asyncio.gather(
-        build_profile_context(user_id),
-        _get_temp_unit(user_id),
-    )
-
-    # ── Pre-processing ──────────────────────────────────────────────────────────
     include_topics, exclude_topics = await load_topic_preferences(user_id)
     topic_scores = await load_topic_reaction_scores(user_id)
 
-    # Parallel raw gather — weather rows fetched in same gather to avoid extra DB round-trip
-    internal_data, external_data, weather_rows = await asyncio.gather(
-        _gather_internal(user_id),
+    external_data, weather_rows, temp_unit = await asyncio.gather(
         _gather_external(user_id),
         get_cached_weather_rows(user_id),
+        _get_temp_unit(user_id),
     )
 
-    # Task change detection
-    all_tasks = internal_data.get("all_tasks_raw", [])
-    changed_tasks, unchanged_count = await split_changed_tasks(user_id, all_tasks)
-
-    # RSS filtering
     raw_rss = external_data.get("rss_items") or []
     filtered_rss = score_and_filter_items(
         raw_rss,
@@ -416,32 +379,23 @@ async def run_compilation(
         if item.get("id")
     ]
 
-    # Weather staleness gate — returns None if data is >24h old
-    weather_card = parse_weather_card_data(weather_rows[0], temp_unit) if weather_rows else None
+    weather_cards = [
+        card for row in weather_rows
+        if (card := parse_weather_card_data(row, temp_unit)) is not None
+    ]
+    weather_card = weather_cards[0] if weather_cards else None
 
-    # ── LLM Synthesis ──────────────────────────────────────────────────────────
-    # Build filtered internal data with only changed tasks
-    internal_data_filtered = dict(internal_data)
-    internal_data_filtered["unchanged_task_count"] = unchanged_count
-    internal_data_filtered["changed_tasks"] = [format_task(t) for t in changed_tasks]
-
-    # Build filtered external data (suppress weather prose — card handles it)
-    external_data_filtered = {
-        "rss_items": filtered_rss,
-        "weather": [],
-    }
-
-    briefing_text = await _llm_synthesise(
-        _unified_system_prompt(profile_context),
-        _unified_user_prompt(internal_data_filtered, external_data_filtered, slot, temp_unit),
-        model,
-        num_ctx=8192,
+    briefing_text, agentic_messages = await run_agentic_briefing(
+        user_id, slot, model, conv_id=None, rss_override=filtered_rss,
     )
 
-    # ── Post-processing ─────────────────────────────────────────────────────────
-    await upsert_task_snapshots(user_id, all_tasks)
-
-    metadata: dict = {"rss_item_ids": rss_item_ids, "rss_items": rss_items_meta, "weather": weather_card}
+    metadata: dict = {
+        "rss_item_ids": rss_item_ids,
+        "rss_items": rss_items_meta,
+        "weather": weather_card,
+    }
+    if agentic_messages:
+        metadata["agentic_messages"] = agentic_messages
 
     if not briefing_text:
         logger.warning("Briefing compilation produced no content for user %d slot %s", user_id, slot)
@@ -450,27 +404,26 @@ async def run_compilation(
     return briefing_text, metadata
 
 
-async def run_slot_injection(user_id: int, slot: str, model: str | None = None) -> str:
+async def run_slot_injection(
+    user_id: int,
+    slot: str,
+    model: str | None = None,
+) -> tuple[str, dict]:
     """
-    Lighter update for 8am/12pm/4pm — gathers fresh data and produces a slot-specific
-    update prompt. Returns the text to inject as a new user→assistant exchange.
+    Lighter check-in update for 8am/12pm/4pm slots.
+
+    Runs the agentic loop with the slot-specific prompt. Returns
+    ``(text, metadata)`` where metadata contains ``agentic_messages``
+    for the scheduler to persist.
     """
     if model is None:
         model = await get_setting(user_id, "default_model", Config.OLLAMA_MODEL)
 
-    internal_data, external_data, temp_unit = await asyncio.gather(
-        _gather_internal(user_id),
-        _gather_external(user_id),
-        _get_temp_unit(user_id),
+    text, agentic_messages = await run_agentic_briefing(
+        user_id, slot, model, conv_id=None,
     )
 
-    system = (
-        f"You are a personal assistant giving a brief {slot} check-in. "
-        "The user already had their morning briefing — focus only on what's changed or newly relevant. "
-        "Speak naturally in 2-3 sentences, no markdown formatting, no headers or bullet points."
-    )
-    return await _llm_synthesise(
-        system,
-        _unified_user_prompt(internal_data, external_data, slot, temp_unit),
-        model,
-    )
+    metadata: dict = {}
+    if agentic_messages:
+        metadata["agentic_messages"] = agentic_messages
+    return text, metadata

src/fabledassistant/services/briefing_scheduler.py

@@ -13,7 +13,7 @@ functions wrapped with asyncio.run_coroutine_threadsafe().
 
 import asyncio
 import logging
-from datetime import date, datetime, time, timedelta
+from datetime import date, datetime, time, timedelta, timezone
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from apscheduler.schedulers.background import BackgroundScheduler
@@ -36,6 +36,11 @@ SLOTS = [
     ("afternoon", 16, 0),
 ]
 
+# Weekly review runs Sunday at 6pm by default
+WEEKLY_REVIEW_DAY = "sun"   # APScheduler day_of_week format
+WEEKLY_REVIEW_HOUR = 18
+WEEKLY_REVIEW_MINUTE = 0
+
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -102,6 +107,26 @@ def _add_user_jobs(user_id: int, tz: str, config: dict | None = None) -> None:
             replace_existing=True,
             misfire_grace_time=3600,
         )
+    # Weekly review job — runs once per week
+    weekly_jid = _job_id(user_id, "weekly_review")
+    weekly_on = enabled_slots.get("weekly_review", True)
+    if weekly_on:
+        _scheduler.add_job(
+            _run_user_slot_sync,
+            CronTrigger(
+                day_of_week=WEEKLY_REVIEW_DAY,
+                hour=WEEKLY_REVIEW_HOUR,
+                minute=WEEKLY_REVIEW_MINUTE,
+                timezone=tz,
+            ),
+            args=[user_id, "weekly_review"],
+            id=weekly_jid,
+            replace_existing=True,
+            misfire_grace_time=7200,
+        )
+    elif _scheduler.get_job(weekly_jid):
+        _scheduler.remove_job(weekly_jid)
+
     logger.info("Scheduled briefing jobs for user %d in timezone %s", user_id, tz)
 
 
@@ -113,6 +138,9 @@ def _remove_user_jobs(user_id: int) -> None:
         jid = _job_id(user_id, slot_name)
         if _scheduler.get_job(jid):
             _scheduler.remove_job(jid)
+    weekly_jid = _job_id(user_id, "weekly_review")
+    if _scheduler.get_job(weekly_jid):
+        _scheduler.remove_job(weekly_jid)
     logger.info("Removed briefing jobs for user %d", user_id)
 
 
@@ -134,6 +162,170 @@ def update_user_schedule(user_id: int, config: dict, tz_override: str | None = N
 
 # ── Job execution ─────────────────────────────────────────────────────────────
 
+async def _auto_pause_stale_projects(user_id: int) -> list[str]:
+    """Pause active projects with no note/task activity in 14+ days. Returns paused project titles."""
+    from sqlalchemy import select as _sel, func as _func
+    from fabledassistant.models.project import Project
+    from fabledassistant.models.note import Note
+    from fabledassistant.models import async_session as _session
+
+    paused: list[str] = []
+    threshold = datetime.now(timezone.utc) - timedelta(days=14)
+    try:
+        async with _session() as session:
+            projects = (await session.execute(
+                _sel(Project).where(Project.user_id == user_id, Project.status == "active")
+            )).scalars().all()
+            for p in projects:
+                latest = (await session.execute(
+                    _sel(_func.max(Note.updated_at)).where(Note.project_id == p.id)
+                )).scalar()
+                if latest is None or latest < threshold:
+                    p.status = "paused"
+                    paused.append(p.title or "Untitled")
+            if paused:
+                await session.commit()
+                logger.info("Auto-paused %d stale projects for user %d: %s", len(paused), user_id, paused)
+    except Exception:
+        logger.debug("Auto-pause check failed for user %d", user_id, exc_info=True)
+    return paused
+
+
+async def _persist_agentic_messages(
+    conv_id: int,
+    slot: str,
+    metadata: dict | None,
+) -> None:
+    """Persist the intermediate turns from an agentic briefing run.
+
+    ``metadata["agentic_messages"]`` is the full message list the agent
+    generated — system prompt, user trigger, assistant tool-call turns,
+    tool-role results, and the final assistant prose.
+
+    To stay compatible with the existing chat loader in ``routes/chat.py``,
+    tool results are folded back into the parent assistant message's
+    ``tool_calls[i]["result"]`` field rather than being persisted as
+    separate ``role="tool"`` rows. This matches how regular chat
+    persists agentic turns, so the follow-up chat endpoint can rehydrate
+    the tool sequence using its existing logic.
+
+    Persists everything except the system prompt (implicit in the chat
+    pipeline) and the final assistant prose (the caller posts that
+    separately with the user-facing metadata block). The synthetic user
+    trigger message is persisted so Ollama sees a user→assistant→user
+    sequence rather than an orphaned assistant reply — it's tagged as
+    intermediate so the UI can hide it.
+
+    Legacy (non-agentic) briefings have no ``agentic_messages`` and this
+    function is a no-op.
+    """
+    from fabledassistant.services.briefing_conversations import post_message
+
+    if not metadata:
+        return
+    agentic_messages = metadata.get("agentic_messages") or []
+    if not agentic_messages:
+        return
+
+    # Drop the system prompt (index 0) and the final assistant prose
+    # (last item). The caller posts the final prose as its own message.
+    middle = agentic_messages[1:-1]
+
+    # Walk the middle sequence, pairing each assistant tool-call turn
+    # with the tool-role results that immediately follow it.
+    i = 0
+    n = len(middle)
+    while i < n:
+        m = middle[i]
+        role = m.get("role", "")
+        content = m.get("content", "") or ""
+        tag = {"briefing_slot": slot, "briefing_intermediate": True}
+
+        if role == "assistant" and m.get("tool_calls"):
+            # Collect subsequent tool-role results, matching them
+            # positionally onto this assistant's tool_calls. Normalise
+            # each entry to the flat storage format the chat loader
+            # expects: {"function": <name>, "arguments": <args>,
+            # "result": <result>, "status": "success"|"error"}.
+            raw_tool_calls = list(m["tool_calls"])
+            flat_tool_calls: list[dict] = []
+            result_idx = 0
+            j = i + 1
+
+            import json as _json
+            for raw_tc in raw_tool_calls:
+                fn = raw_tc.get("function") or {}
+                name = fn.get("name") if isinstance(fn, dict) else str(fn)
+                arguments = fn.get("arguments") if isinstance(fn, dict) else {}
+                if isinstance(arguments, str):
+                    try:
+                        arguments = _json.loads(arguments)
+                    except Exception:
+                        arguments = {}
+
+                # Pair up with the next available tool-role message
+                parsed_result: object = {}
+                status = "success"
+                if j < n and middle[j].get("role") == "tool":
+                    tool_content = middle[j].get("content", "") or ""
+                    try:
+                        parsed_result = _json.loads(tool_content)
+                    except Exception:
+                        parsed_result = tool_content
+                    if isinstance(parsed_result, dict) and parsed_result.get("success") is False:
+                        status = "error"
+                    j += 1
+                    result_idx += 1
+
+                flat_tool_calls.append({
+                    "function": name,
+                    "arguments": arguments,
+                    "result": parsed_result,
+                    "status": status,
+                })
+
+            try:
+                await post_message(
+                    conv_id, "assistant", content,
+                    metadata=tag,
+                    tool_calls=flat_tool_calls,
+                )
+            except Exception:
+                logger.warning(
+                    "Failed to persist agentic assistant turn for conv %d slot %s",
+                    conv_id, slot, exc_info=True,
+                )
+            i = j  # skip the tool results we just folded in
+            continue
+
+        if role == "tool":
+            # Unpaired tool result — shouldn't normally happen, but be
+            # defensive and persist it as an assistant-visible note so we
+            # don't lose the receipt entirely.
+            i += 1
+            continue
+
+        if role == "user":
+            # Skip the synthetic user trigger ("Generate my morning briefing…").
+            # Persisting it would recreate the exact "[Midday briefing update]"
+            # problem PR 2 is designed to eliminate: fake user messages
+            # cluttering chat history. The LLM can follow an all-assistant
+            # sequence just fine since the chat endpoint injects the real
+            # system prompt on follow-up.
+            i += 1
+            continue
+
+        # assistant without tool_calls — persist as-is (rare intermediate)
+        try:
+            await post_message(conv_id, role, content, metadata=tag)
+        except Exception:
+            logger.warning(
+                "Failed to persist agentic %s message for conv %d slot %s",
+                role, conv_id, slot, exc_info=True,
+            )
+        i += 1
+
+
 async def _run_slot_for_user(user_id: int, slot: str) -> None:
     """Execute one slot job for one user."""
     from fabledassistant.services.briefing_conversations import (
@@ -164,13 +356,18 @@ async def _run_slot_for_user(user_id: int, slot: str) -> None:
     model = await get_setting(user_id, "default_model", Config.OLLAMA_MODEL)
 
     if slot == "compilation":
+        # Auto-pause stale projects before compiling the briefing
+        await _auto_pause_stale_projects(user_id)
+
         # Refresh external data first
         try:
             import json
-            from fabledassistant.services.rss import refresh_all_feeds
             config_raw = await get_setting(user_id, "briefing_config", "{}")
             config = json.loads(config_raw) if isinstance(config_raw, str) else {}
-            await refresh_all_feeds(user_id)
+            rss_on = (await get_setting(user_id, "rss_enabled", "false")).lower() == "true"
+            if rss_on:
+                from fabledassistant.services.rss import refresh_all_feeds
+                await refresh_all_feeds(user_id)
             from fabledassistant.services import weather as wx
             for key, loc in config.get("locations", {}).items():
                 if loc.get("lat") and loc.get("lon"):
@@ -188,14 +385,28 @@ async def _run_slot_for_user(user_id: int, slot: str) -> None:
         conv = await get_or_create_today_conversation(user_id, model)
         text, metadata = await run_compilation(user_id, slot, model)
         if text:
-            await post_message(conv.id, "assistant", text, metadata=metadata)
+            # Persist the agentic tool-call sequence as its own messages
+            # so follow-up chat can see the receipts. Each intermediate
+            # message is tagged with briefing_slot so the chat context
+            # loader can decide whether to include them in history.
+            await _persist_agentic_messages(conv.id, slot, metadata)
+            final_meta = {k: v for k, v in metadata.items() if k != "agentic_messages"}
+            final_meta["briefing_slot"] = slot
+            await post_message(conv.id, "assistant", text, metadata=final_meta)
 
     else:
         conv = await get_or_create_today_conversation(user_id, model)
-        text = await run_slot_injection(user_id, slot, model)
+        text, slot_metadata = await run_slot_injection(user_id, slot, model)
         if text:
-            await post_message(conv.id, "user", f"[{slot.title()} briefing update]")
-            await post_message(conv.id, "assistant", text)
+            # No more synthetic "[Midday briefing update]" user-role
+            # messages. Slot updates are plain assistant messages tagged
+            # with briefing_slot so the chat endpoint can filter them
+            # from the LLM's view of history on follow-ups (they remain
+            # visible in the UI).
+            await _persist_agentic_messages(conv.id, slot, slot_metadata)
+            final_meta = {k: v for k, v in slot_metadata.items() if k != "agentic_messages"}
+            final_meta["briefing_slot"] = slot
+            await post_message(conv.id, "assistant", text, metadata=final_meta)
 
     try:
         from fabledassistant.services.push import send_push_notification
@@ -235,10 +446,13 @@ async def _run_profile_closeout(user_id: int, model: str) -> None:
     and append them to the briefing profile note.
     """
     from fabledassistant.services.user_profile import append_observations
-    from fabledassistant.services.briefing_pipeline import _llm_synthesise
+    from fabledassistant.services.llm import generate_completion
+    from fabledassistant.services.tz import user_today
     from fabledassistant.models.conversation import Conversation, Message
 
-    yesterday = (date.today() - timedelta(days=1))
+    # User-local "yesterday" so closeout always targets the day that just
+    # ended in the user's timezone, regardless of container TZ.
+    yesterday = (await user_today(user_id)) - timedelta(days=1)
     async with async_session() as session:
         result = await session.execute(
             select(Conversation).where(
@@ -268,7 +482,17 @@ async def _run_profile_closeout(user_id: int, model: str) -> None:
         "Example: '- User skipped news about finance', '- Prefers weather for home location first'. "
         "If nothing notable, output only: (nothing to note)"
     )
-    observations = await _llm_synthesise(system, transcript, model)
+    try:
+        observations = (await generate_completion(
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": transcript},
+            ],
+            model,
+        )).strip()
+    except Exception:
+        logger.warning("Profile closeout synthesis failed for user %d", user_id, exc_info=True)
+        observations = ""
     if observations and "(nothing to note)" not in observations.lower():
         await append_observations(user_id, observations)
 

src/fabledassistant/services/briefing_tools.py

@@ -0,0 +1,9 @@
+"""Briefing tool subset — delegates to the registry's ``briefing=True`` filter.
+
+Tools are opted-in to briefings via ``@tool(briefing=True)`` in their
+respective module, so there is no separate allowlist to maintain here.
+"""
+
+from fabledassistant.services.tools import get_briefing_tools
+
+__all__ = ["get_briefing_tools"]

src/fabledassistant/services/chat.py

@@ -187,6 +187,7 @@ async def add_message(
     context_note_id: int | None = None,
     status: str | None = None,
     tool_calls: list | None = None,
+    msg_metadata: dict | None = None,
 ) -> Message:
     async with async_session() as session:
         kwargs: dict = dict(
@@ -199,6 +200,8 @@ async def add_message(
             kwargs["status"] = status
         if tool_calls is not None:
             kwargs["tool_calls"] = tool_calls
+        if msg_metadata is not None:
+            kwargs["msg_metadata"] = msg_metadata
         msg = Message(**kwargs)
         session.add(msg)
         # Touch conversation updated_at

src/fabledassistant/services/email.py

@@ -40,29 +40,35 @@ _EMAIL_LOGO_SVG = (
 def _email_html(title: str, body: str) -> str:
     """Wrap email body content in the standard Fabled Assistant template."""
     return f"""<!DOCTYPE html>
-<html>
-<head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head>
-<body style="margin:0;padding:0;background:#f3f4f6;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;">
-  <div style="padding:32px 16px;">
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="color-scheme" content="light">
+</head>
+<body style="margin:0;padding:0;background:#f5f3ff;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,'Helvetica Neue',Arial,sans-serif;">
+  <div style="padding:36px 16px 48px;">
     <div style="max-width:520px;margin:0 auto;">
-      <div style="background:#ffffff;border:1px solid #e5e7eb;border-radius:8px;overflow:hidden;">
+
+      <!-- Card -->
+      <div style="background:#ffffff;border:1px solid #ddd6fe;border-radius:14px;overflow:hidden;box-shadow:0 4px 24px rgba(109,40,217,0.08);">
 
         <!-- Header -->
-        <div style="background:#6366f1;padding:20px 24px;text-align:center;">
-          <div style="margin-bottom:6px;">
-            {_EMAIL_LOGO_SVG}<span style="display:inline-block;vertical-align:middle;color:#ffffff;font-size:17px;font-weight:600;letter-spacing:0.01em;">Fabled Assistant</span>
+        <div style="background:linear-gradient(135deg,#7c3aed 0%,#6d28d9 100%);padding:24px 28px;text-align:center;">
+          <div style="margin-bottom:8px;">
+            {_EMAIL_LOGO_SVG}<span style="display:inline-block;vertical-align:middle;color:#ffffff;font-size:18px;font-weight:700;letter-spacing:0.01em;">Fabled Assistant</span>
           </div>
-          <p style="margin:0;color:#c7d2fe;font-size:13px;">{title}</p>
+          <p style="margin:0;color:#ede9fe;font-size:13px;letter-spacing:0.03em;">{title}</p>
         </div>
 
         <!-- Body -->
-        <div style="padding:28px 24px;">
+        <div style="padding:32px 28px;color:#1e1b4b;">
           {body}
         </div>
 
         <!-- Footer -->
-        <div style="border-top:1px solid #e5e7eb;padding:14px 24px;text-align:center;background:#f9fafb;">
-          <p style="margin:0;color:#9ca3af;font-size:12px;">This email was sent by your Fabled Assistant instance.</p>
+        <div style="border-top:1px solid #ede9fe;padding:16px 28px;text-align:center;background:#faf5ff;">
+          <p style="margin:0;color:#a78bfa;font-size:12px;">Sent by your Fabled Assistant instance.</p>
         </div>
 
       </div>
@@ -169,7 +175,7 @@ async def send_email(to: str, subject: str, html_body: str) -> None:
 async def send_test_email(to: str) -> None:
     """Send a branded test email."""
     body = """
-        <p style="margin:0 0 12px;color:#111827;font-size:15px;font-weight:600;">SMTP is configured correctly</p>
+        <p style="margin:0 0 12px;color:#1e1b4b;font-size:15px;font-weight:600;">SMTP is configured correctly</p>
         <p style="margin:0;color:#6b7280;font-size:14px;">Your Fabled Assistant instance can send email notifications.</p>
     """
     await send_email(to, "Fabled Assistant - Test Email", _email_html("Test Email", body))

src/fabledassistant/services/events.py

@@ -7,7 +7,7 @@ import uuid
 from datetime import datetime, timedelta, timezone
 
 from dateutil.rrule import rrulestr
-from sqlalchemy import or_, select
+from sqlalchemy import and_, or_, select
 
 from fabledassistant.models import async_session
 from fabledassistant.models.event import Event
@@ -85,19 +85,30 @@ async def list_events(
     dicts (same shape as Event.to_dict()).
     """
     async with async_session() as session:
+        # Match strategy:
+        #   - Recurring events: fetch all, expand via rrule below.
+        #   - Non-recurring with an end_dt: standard overlap — starts before
+        #     date_to and ends after date_from.
+        #   - Non-recurring with no end_dt: treat as a point event at
+        #     start_dt, include only if start_dt falls within the window.
+        #     (Previously this branch matched any event with a null end_dt,
+        #     returning all past events as "happening today".)
         result = await session.execute(
             select(Event).where(
                 Event.user_id == user_id,
-                # Base window: non-recurring events must overlap range;
-                # recurring events always need to be fetched so they can be expanded.
                 or_(
                     Event.recurrence.isnot(None),
-                    Event.start_dt <= date_to,
-                ),
-                or_(
-                    Event.end_dt.is_(None),
-                    Event.end_dt >= date_from,
-                    Event.recurrence.isnot(None),
+                    and_(
+                        Event.recurrence.is_(None),
+                        Event.start_dt <= date_to,
+                        or_(
+                            Event.end_dt >= date_from,
+                            and_(
+                                Event.end_dt.is_(None),
+                                Event.start_dt >= date_from,
+                            ),
+                        ),
+                    ),
                 ),
             ).order_by(Event.start_dt)
         )

src/fabledassistant/services/generation_task.py

@@ -36,73 +36,91 @@ _TOOL_CALL_MARKER = re.compile(r"^\s*\[TOOL_CALLS\]\s*", re.IGNORECASE)
 
 DB_FLUSH_INTERVAL = 5.0  # seconds between partial DB flushes
 
-# ---------------------------------------------------------------------------
-# Conditional thinking classifier
-# ---------------------------------------------------------------------------
 
-# Patterns that force think=True even on short messages
-_THINK_FORCE = re.compile(
-    r"\b("
-    r"analyz|compar|explain\s+why|help\s+me\s+(think|plan|understand|figure\s+out)|"
-    r"step[- ]by[- ]step|debug|troubleshoot|diagnos|"
-    r"pros\s+and\s+cons|trade[- ]?off|"
-    r"architect|design\s+(a|the|my|this)|"
-    r"write\s+a\s+(detailed|long|comprehensive|full)|"
-    r"brainstorm|outline\s+(a|the|my)|"
-    r"what\s+(are|is)\s+the\s+(best|difference|relationship|impact|implication)|"
-    r"how\s+(do|does|should|would|can)\s+.{0,40}\s+work|"
-    r"why\s+(is|are|does|do|did|would|should)\b"
-    r")",
-    re.IGNORECASE,
-)
+async def _maybe_save_article_discussion_note(
+    user_id: int, conv_id: int, reply_content: str,
+) -> None:
+    """Persist a seeded article-discussion's first reply as a Note.
 
-# Patterns that force think=False regardless of message length
-_THINK_SKIP = re.compile(
-    r"^(hi|hey|hello|thanks|thank\s+you|ok|okay|got\s+it|sounds\s+good|"
-    r"great|perfect|sure|yes|no|yep|nope|nice|cool|awesome|"
-    r"what('s| is) \d|what time|how many|remind me|add (a |an )?(task|note|reminder)|"
-    r"create (a |an )?(task|note)|delete|update|mark .{0,30} (done|complete))\b",
-    re.IGNORECASE,
-)
+    Fires after ``run_generation`` completes. Looks for a synthetic
+    read_article seed message on the conversation; if found AND the linked
+    ``rss_items`` row has no ``discussion_note_id`` yet, saves ``reply_content``
+    as a Note, tags it, and writes the backlink. Subsequent discuss clicks on
+    the same article are a no-op (already linked).
 
-_WORD_COUNT_THRESHOLD = 60  # messages over this word count always use think=True
-_SHORT_MESSAGE_THRESHOLD = 12  # messages under this always use think=False
-
-
-def _should_think(user_content: str, think_requested: bool) -> bool:
-    """Return whether extended thinking should be used for this request.
-
-    If the caller didn't request thinking, we never enable it. If they did,
-    we check whether the message is complex enough to warrant the overhead.
+    Failures are logged and swallowed — the chat UI should never break because
+    Note persistence hit a snag.
     """
-    if not think_requested:
-        return False
+    try:
+        if not reply_content or not reply_content.strip():
+            return
+        from sqlalchemy import select as _select
+        from fabledassistant.models.conversation import Message as _Message
+        from fabledassistant.models.rss_feed import RssItem as _RssItem
+        from fabledassistant.services.notes import create_note
 
-    text = user_content.strip()
-    word_count = len(text.split())
+        async with async_session() as session:
+            result = await session.execute(
+                _select(_Message)
+                .where(_Message.conversation_id == conv_id)
+                .order_by(_Message.id.asc())
+            )
+            messages = result.scalars().all()
+            seed_meta = None
+            for m in messages:
+                meta = m.msg_metadata or {}
+                if meta.get("article_seed") and meta.get("rss_item_id"):
+                    seed_meta = meta
+                    break
+            if seed_meta is None:
+                return
+            item_id = int(seed_meta["rss_item_id"])
+            item = await session.get(_RssItem, item_id)
+            if item is None or item.discussion_note_id is not None:
+                return
+            article_title = (item.title or "Untitled article").strip()
+            article_url = item.url
+            article_topics = list(item.topics or [])
 
-    if word_count <= _SHORT_MESSAGE_THRESHOLD:
-        return False
-    if _THINK_SKIP.match(text):
-        return False
-    if word_count >= _WORD_COUNT_THRESHOLD:
-        return True
-    if "```" in text:
-        return True
-    if _THINK_FORCE.search(text):
-        return True
-
-    return False
+        note_title = f"Article: {article_title}"[:200]
+        body_parts = [f"**Source:** {article_url}"] if article_url else []
+        body_parts.append(reply_content.strip())
+        note_body = "\n\n".join(body_parts)
+        tags = ["article-summary"] + [t for t in article_topics if t]
+        note = await create_note(
+            user_id=user_id,
+            title=note_title,
+            body=note_body,
+            tags=tags,
+            entity_meta={
+                "source": "article_discussion",
+                "rss_item_id": item_id,
+                "url": article_url,
+                "conversation_id": conv_id,
+            },
+        )
 
+        async with async_session() as session:
+            fresh = await session.get(_RssItem, item_id)
+            if fresh is not None and fresh.discussion_note_id is None:
+                fresh.discussion_note_id = note.id
+                await session.commit()
+        logger.info(
+            "Saved article-discussion summary as note %d for rss_item %d (conv %d)",
+            note.id, item_id, conv_id,
+        )
+    except Exception:
+        logger.warning(
+            "Failed to persist article-discussion note for conv %d",
+            conv_id, exc_info=True,
+        )
 
 # 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",
-    "delete_note": "Deleting note",
-    "delete_task": "Deleting task",
-    "get_note": "Reading note",
+    "create_note": "Creating note/task",
+    "update_note": "Updating note/task",
+    "delete_note": "Deleting note/task",
+    "read_note": "Reading note",
     "list_notes": "Listing notes",
     "list_tasks": "Searching tasks",
     "search_notes": "Searching notes (semantic)",
@@ -112,7 +130,7 @@ _TOOL_LABELS: dict[str, str] = {
     "update_event": "Updating calendar event",
     "delete_event": "Removing calendar event",
     "list_calendars": "Listing calendars",
-    "search_web": "Searching the web",
+    "lookup": "Looking up information",
     "research_topic": "Researching topic",
 }
 
@@ -275,25 +293,33 @@ async def run_generation(
         voice_speech_style=voice_speech_style,
     )
 
-    # Pick the smallest context tier that fits the current messages.
+    # Pick the smallest context tier that fits the current messages AND the
+    # tool schemas (which can be 6-10K tokens on their own with ~40 tools).
     # Using the minimum needed tier reduces KV cache size and speeds up prefill.
-    num_ctx = pick_num_ctx(messages)
+    num_ctx = pick_num_ctx(messages, tools=tools)
     logger.debug("Adaptive num_ctx=%d for conv %d", num_ctx, conv_id)
 
     # Emit context event
     buf.append_event("context", {"context": context_meta})
 
-    # Apply thinking classifier — downgrade think=True for simple/conversational messages
-    think = _should_think(user_content, think)
+    # Always think on qwen3-class models: reasoning mode is the only reliable
+    # path for the tool-call template. Content-based gating was tried in 87fcaa6
+    # but exposed silent-generation failures on short tool-intent prompts, since
+    # the classifier had no way to tell that "create a task" needs a tool call.
+    think_requested = think
+    think = True
 
     t_start = time.monotonic()
     timing: dict = {
+        "think_requested": think_requested,
         "think": think,
         "num_ctx": num_ctx,
         "tools": [],
         "rounds": 0,
         "prompt_tokens": None,
         "output_tokens": None,
+        "first_token_ms": None,
+        "thinking_ms": None,
         "ttft_ms": None,
         "generation_ms": None,
         "total_ms": None,
@@ -319,17 +345,35 @@ async def run_generation(
             buf.append_event("status", {"status": "Generating response..." if _round == 0 else "Composing response..."})
             t_stream = time.monotonic()
 
+            approx_msg_chars = sum(len(str(m.get("content", ""))) for m in messages)
+            round_content_start = len(buf.content_so_far)
+            round_output_tokens_start = timing.get("output_tokens") or 0
+            round_prompt_tokens_start = timing.get("prompt_tokens") or 0
+            logger.info(
+                "CTX_DIAG round_start conv=%d round=%d num_ctx=%d msgs=%d approx_chars=%d think=%s",
+                conv_id, _round, num_ctx, len(messages), approx_msg_chars, think,
+            )
             async for chunk in _stream_with_retry(messages, model, tools, think, num_ctx=num_ctx):
                 if buf.cancel_event.is_set():
                     cancelled = True
                     break
 
                 if chunk.type == "thinking":
+                    if timing["first_token_ms"] is None:
+                        timing["first_token_ms"] = int((time.monotonic() - t_start) * 1000)
                     buf.append_event("thinking_chunk", {"chunk": chunk.content})
 
                 elif chunk.type == "content":
                     if timing["ttft_ms"] is None:
-                        timing["ttft_ms"] = int((time.monotonic() - t_start) * 1000)
+                        now_ms = int((time.monotonic() - t_start) * 1000)
+                        timing["ttft_ms"] = now_ms
+                        if timing["first_token_ms"] is None:
+                            # No thinking phase occurred — first token IS content.
+                            timing["first_token_ms"] = now_ms
+                        else:
+                            # Thinking phase duration = gap between first thinking
+                            # token and first content token.
+                            timing["thinking_ms"] = now_ms - timing["first_token_ms"]
                     buf.content_so_far += chunk.content
                     clean = _TOOL_CALL_MARKER.sub("", chunk.content)
                     if clean:
@@ -376,8 +420,9 @@ async def run_generation(
                                 buf.content_so_far += done_text
                             except Exception as e:
                                 logger.exception("Research pipeline failed for topic: %s", topic)
-                                result = {"success": False, "error": str(e)}
-                                err_text = f"\nResearch failed: {e}"
+                                err_msg = str(e) or f"{type(e).__name__}: unexpected error"
+                                result = {"success": False, "error": err_msg}
+                                err_text = f"\nResearch failed: {err_msg}"
                                 buf.append_event("chunk", {"chunk": err_text})
                                 buf.content_so_far += err_text
                             research_completed = True
@@ -406,6 +451,21 @@ async def run_generation(
                         all_tool_calls.append(tool_record)
                         buf.append_event("tool_call", {"tool_call": tool_record})
 
+            round_content_added = len(buf.content_so_far) - round_content_start
+            round_output_tokens_added = (timing.get("output_tokens") or 0) - round_output_tokens_start
+            round_prompt_tokens = (timing.get("prompt_tokens") or 0) - round_prompt_tokens_start
+            headroom = num_ctx - round_prompt_tokens if round_prompt_tokens else None
+            is_silent = (
+                not round_tool_calls
+                and round_content_added == 0
+                and round_output_tokens_added > 0
+            )
+            logger.info(
+                "CTX_DIAG round_end conv=%d round=%d think=%s prompt_tokens=%d output_tokens=%d headroom=%s content_added=%d tool_calls=%d silent=%s",
+                conv_id, _round, think, round_prompt_tokens, round_output_tokens_added,
+                headroom, round_content_added, len(round_tool_calls), is_silent,
+            )
+
             timing["generation_ms"] = int((time.monotonic() - t_stream) * 1000)
 
             if cancelled:
@@ -440,6 +500,29 @@ async def run_generation(
         # Strip model artifacts from final content
         buf.content_so_far = _TOOL_CALL_MARKER.sub("", buf.content_so_far)
 
+        # Silent-generation safety net: the model burned output tokens but
+        # nothing landed in content or tool_calls (seen with qwen3:14b when
+        # its tool-call emission doesn't parse). Show a visible fallback so
+        # the user isn't staring at an empty bubble.
+        if (
+            not cancelled
+            and not buf.content_so_far.strip()
+            and not all_tool_calls
+            and (timing.get("output_tokens") or 0) > 0
+        ):
+            logger.warning(
+                "Silent generation for conv %d: output_tokens=%s but empty content "
+                "and no tool calls (model=%s)",
+                conv_id, timing.get("output_tokens"), model,
+            )
+            fallback = (
+                "I wasn't able to produce a usable response — the model generated "
+                "tokens that couldn't be parsed as content or a tool call. "
+                "Please try rephrasing, or try again."
+            )
+            buf.content_so_far = fallback
+            buf.append_event("chunk", {"chunk": fallback})
+
         # Final save
         logger.info("Generation complete for conv %d: content_length=%d, tool_calls=%d",
                      conv_id, len(buf.content_so_far), len(all_tool_calls))
@@ -452,9 +535,13 @@ async def run_generation(
 
         timing["total_ms"] = int((time.monotonic() - t_start) * 1000)
         logger.info(
-            "Generation timing for conv %d: total=%dms ttft=%s tools=%s generation=%s",
-            conv_id, timing["total_ms"], timing["ttft_ms"],
-            [(t["name"], t["ms"]) for t in timing["tools"]], timing["generation_ms"],
+            "Generation timing for conv %d: total=%dms think=%s(req=%s) first_token=%s "
+            "thinking=%s ttft=%s generation=%s tools=%s",
+            conv_id, timing["total_ms"],
+            timing["think"], timing["think_requested"],
+            timing["first_token_ms"], timing["thinking_ms"], timing["ttft_ms"],
+            timing["generation_ms"],
+            [(t["name"], t["ms"]) for t in timing["tools"]],
         )
         try:
             await log_generation(user_id, conv_id, model, timing)
@@ -499,10 +586,35 @@ async def run_generation(
         msg_count = len(non_system)
         should_gen_title = not conv_title or (msg_count > 0 and msg_count % 10 == 0)
 
+        # Persist article-discussion seed conversations as a Note on their
+        # first assistant reply. This makes "Discuss" summaries part of RAG
+        # so the knowledge base stops being amnesiac about articles the user
+        # has already engaged with. The hook detects a seeded conversation by
+        # finding a synthetic read_article assistant message whose
+        # msg_metadata carries ``article_seed: True`` and whose rss_items row
+        # has no discussion_note_id yet. Fire-and-forget so the done event
+        # lands immediately.
+        asyncio.create_task(_maybe_save_article_discussion_note(
+            user_id, conv_id, buf.content_so_far,
+        ))
+
         if should_gen_title:
-            title_messages = messages + [
-                {"role": "assistant", "content": buf.content_so_far}
+            # Feed the title model the *raw* conversation turns only — never
+            # the post-build_context ``messages`` list. ``build_context``
+            # prepends RAG snippets, RSS excerpts, URL content, and briefing
+            # article dumps INTO the user message string itself, so filtering
+            # by role="user" downstream still surfaces that noise as the
+            # "user's message". That pollution caused wildly-wrong titles
+            # (bug #109) — the small background model was staring at article
+            # excerpts instead of what the user actually typed. Pass the
+            # original history + the raw user_content + the assistant reply.
+            title_messages: list[dict] = [
+                {"role": m["role"], "content": m.get("content") or ""}
+                for m in history
+                if m.get("role") in ("user", "assistant")
             ]
+            title_messages.append({"role": "user", "content": user_content})
+            title_messages.append({"role": "assistant", "content": buf.content_so_far})
 
             async def _bg_title() -> None:
                 try:

src/fabledassistant/services/knowledge.py

@@ -29,10 +29,15 @@ def _note_to_item(note: Note) -> dict:
         item["relationship"] = meta.get("relationship", "")
         item["email"] = meta.get("email", "")
         item["phone"] = meta.get("phone", "")
+        item["birthday"] = meta.get("birthday", "")
+        item["organization"] = meta.get("organization", "")
+        item["address"] = meta.get("address", "")
     elif note.entity_type == "place":
         item["address"] = meta.get("address", "")
         item["phone"] = meta.get("phone", "")
         item["hours"] = meta.get("hours", "")
+        item["website"] = meta.get("website", "")
+        item["category"] = meta.get("category", "")
     elif note.entity_type == "list":
         # Parse markdown task list syntax into structured items
         body = note.body or ""
@@ -117,34 +122,74 @@ async def _semantic_knowledge_search(
     limit: int,
     offset: int,
 ) -> tuple[list[dict], int]:
-    """Semantic search over knowledge objects, with SQL filters applied post-rank."""
+    """Hybrid search: keyword matches first (title/body ILIKE), then semantic results.
+
+    Exact keyword matches always rank above semantic-only matches so that
+    searching for a name like "Weston" surfaces the note with that title
+    before conceptually related notes.
+    """
+    # 1. Keyword search — title and body ILIKE
+    keyword_notes: list[Note] = []
+    try:
+        async with async_session() as session:
+            pattern = f"%{q}%"
+            base = (
+                select(Note)
+                .where(Note.user_id == user_id)
+                .where(Note.title.ilike(pattern) | Note.body.ilike(pattern))
+            )
+            if note_type == "task":
+                base = base.where(Note.status.isnot(None))
+            elif note_type:
+                base = base.where(Note.note_type == note_type).where(Note.status.is_(None))
+            for tag in tags:
+                base = base.where(Note.tags.contains([tag]))
+            # Title matches first, then body-only matches, newest first within each
+            base = base.order_by(
+                Note.title.ilike(pattern).desc(),
+                Note.updated_at.desc(),
+            ).limit(limit * 2)
+            keyword_notes = list((await session.execute(base)).scalars().all())
+    except Exception:
+        logger.warning("Keyword search failed", exc_info=True)
+
+    # 2. Semantic search — conceptual similarity
+    semantic_notes: list[Note] = []
     try:
         from fabledassistant.services.embeddings import semantic_search_notes
-        # Fetch a larger candidate set to allow for filtering
         is_task_filter = True if note_type == "task" else (False if note_type else None)
         candidates = await semantic_search_notes(
             user_id=user_id,
             query=q,
-            limit=min(200, limit * 8),
+            limit=min(200, limit * 4),
             threshold=0.3,
             is_task=is_task_filter,
         )
+        for _score, note in candidates:
+            if note_type == "task" and not note.is_task:
+                continue
+            elif note_type and note_type != "task" and note.entity_type != note_type:
+                continue
+            if tags and not all(t in (note.tags or []) for t in tags):
+                continue
+            semantic_notes.append(note)
     except Exception:
-        logger.warning("Semantic search unavailable, falling back to SQL", exc_info=True)
-        return await query_knowledge(user_id, note_type, tags, "modified", None, limit, offset)
+        logger.warning("Semantic search unavailable, using keyword results only", exc_info=True)
 
-    results = []
-    for _score, note in candidates:
-        if note_type == "task" and not note.is_task:
-            continue
-        elif note_type and note_type != "task" and note.entity_type != note_type:
-            continue
-        if tags and not all(t in (note.tags or []) for t in tags):
-            continue
-        results.append(note)
+    # 3. Merge — keyword matches first, then semantic (deduplicated)
+    seen_ids: set[int] = set()
+    merged: list[Note] = []
+    for note in keyword_notes:
+        if note.id not in seen_ids:
+            seen_ids.add(note.id)
+            merged.append(note)
+    for note in semantic_notes:
+        if note.id not in seen_ids:
+            seen_ids.add(note.id)
+            merged.append(note)
 
-    total = len(results)
-    page_items = results[offset: offset + limit]
+    total = len(merged)
+    page_items = merged[offset: offset + limit]
     return [_note_to_item(n) for n in page_items], total
 
 

src/fabledassistant/services/llm.py

@@ -26,12 +26,32 @@ logger = logging.getLogger(__name__)
 _CTX_TIERS = (8192, 16384, 32768)
 
 
-def pick_num_ctx(messages: list[dict]) -> int:
-    """Return the smallest context tier that fits *messages* with 25% headroom.
+def keep_alive_for(model: str) -> str:
+    """Return the Ollama keep_alive duration for *model*.
+
+    Background models get a shorter window because they're called
+    sporadically; the main interactive model gets a longer one so it
+    stays warm between user messages.
+    """
+    if model == Config.OLLAMA_BACKGROUND_MODEL:
+        return Config.OLLAMA_KEEP_ALIVE_BACKGROUND
+    return Config.OLLAMA_KEEP_ALIVE_MAIN
+
+
+def pick_num_ctx(messages: list[dict], tools: list[dict] | None = None) -> int:
+    """Return the smallest context tier that fits *messages* + *tools* with 25% headroom.
+
+    The ``tools`` JSON schemas are a large, often-overlooked chunk of the prompt.
+    With ~40 tools in the registry the schemas alone can be 6-10K tokens — enough
+    that omitting them from the estimate causes silent prompt truncation.
 
     Stays at or below Config.OLLAMA_NUM_CTX (the configured ceiling).
     """
     total_chars = sum(len(m.get("content") or "") for m in messages)
+    if tools:
+        # Serialize the same way Ollama will see them. json.dumps gives us a
+        # faithful char count for the schema payload without any guesswork.
+        total_chars += len(json.dumps(tools))
     estimated_tokens = int(total_chars / 3.5)
     needed = int(estimated_tokens * 1.25) + 256  # 25% headroom + output buffer
     cap = Config.OLLAMA_NUM_CTX
@@ -58,7 +78,14 @@ RAG_AUTO_SNIPPET = 4000
 
 
 async def get_installed_models() -> set[str]:
-    """Return set of installed Ollama model names (with and without :latest)."""
+    """Return set of installed Ollama model names (with and without :latest).
+
+    Tags are normalized to lowercase. Ollama stores whatever casing was used at
+    pull time (``ollama pull gemma3:12B`` keeps the ``B``), but inference calls
+    against the capitalized tag can 400 — the two code paths are inconsistent.
+    Lowercasing on read avoids exposing that mixed-case name in the UI and
+    keeps the validation check below from accepting a form Ollama will reject.
+    """
     try:
         async with httpx.AsyncClient(timeout=10.0) as client:
             resp = await client.get(f"{Config.OLLAMA_URL}/api/tags")
@@ -66,7 +93,7 @@ async def get_installed_models() -> set[str]:
             data = resp.json()
             names: set[str] = set()
             for m in data.get("models", []):
-                name = m["name"]
+                name = m["name"].lower()
                 names.add(name)
                 if name.endswith(":latest"):
                     names.add(name.removesuffix(":latest"))
@@ -78,6 +105,9 @@ async def get_installed_models() -> set[str]:
 
 async def ensure_model(model: str) -> None:
     """Check if model exists in Ollama, pull if missing."""
+    # Match the lowercase normalization in get_installed_models so a legacy
+    # mixed-case setting doesn't force a spurious re-pull at startup.
+    model = model.lower()
     try:
         installed = await get_installed_models()
         if model in installed or f"{model}:latest" in installed:
@@ -129,6 +159,24 @@ async def wait_for_model_loaded(model: str, timeout: float = 90.0) -> bool:
         await asyncio.sleep(min(2.0, remaining))
 
 
+async def _raise_ollama_error(resp: httpx.Response, model: str) -> None:
+    """On a non-2xx Ollama response, log its body before raising.
+
+    ``resp.raise_for_status()`` alone throws away Ollama's error body, which
+    carries the actual reason (e.g. ``"model does not support tools"``,
+    ``"context length exceeded"``). Reading the body first means failures
+    surface a usable message instead of a bare HTTPStatusError.
+    """
+    if resp.status_code < 400:
+        return
+    body = (await resp.aread()).decode("utf-8", errors="replace").strip()
+    logger.error(
+        "Ollama /api/chat %d for model=%s: %s",
+        resp.status_code, model, body[:500],
+    )
+    resp.raise_for_status()
+
+
 async def stream_chat(
     messages: list[dict],
     model: str,
@@ -145,7 +193,7 @@ async def stream_chat(
     merged_options = {"num_ctx": num_ctx or Config.OLLAMA_NUM_CTX}
     if options:
         merged_options.update(options)
-    payload: dict = {"model": model, "messages": messages, "stream": True, "options": merged_options, "think": think, "keep_alive": "2h"}
+    payload: dict = {"model": model, "messages": messages, "stream": True, "options": merged_options, "think": think, "keep_alive": keep_alive_for(model)}
     # read=None: no per-chunk timeout — Ollama may pause for any duration while
     # processing a large input context before the first token arrives.
     async with httpx.AsyncClient(timeout=httpx.Timeout(connect=30.0, read=None, write=None, pool=30.0)) as client:
@@ -154,7 +202,7 @@ async def stream_chat(
             f"{Config.OLLAMA_URL}/api/chat",
             json=payload,
         ) as resp:
-            resp.raise_for_status()
+            await _raise_ollama_error(resp, model)
             async for line in resp.aiter_lines():
                 if not line.strip():
                     continue
@@ -204,7 +252,7 @@ async def stream_chat_with_tools(
         "stream": True,
         "options": options,
         "think": think,
-        "keep_alive": "2h",
+        "keep_alive": keep_alive_for(model),
     }
     if tools:
         payload["tools"] = tools
@@ -215,22 +263,33 @@ async def stream_chat_with_tools(
             f"{Config.OLLAMA_URL}/api/chat",
             json=payload,
         ) as resp:
-            resp.raise_for_status()
+            await _raise_ollama_error(resp, model)
             accumulated_tool_calls: list[dict] = []
+            # Silent-generation diagnostic: if Ollama reports non-zero eval_count
+            # but we never yielded any thinking/content/tool_calls, something
+            # in the frames isn't landing in a field we read. Capture the last
+            # few frames so we can see what Ollama actually sent.
+            yielded_anything = False
+            recent_frames: list[str] = []
             async for line in resp.aiter_lines():
                 if not line.strip():
                     continue
+                if len(recent_frames) >= 5:
+                    recent_frames.pop(0)
+                recent_frames.append(line[:500])
                 data = json.loads(line)
                 msg = data.get("message", {})
 
                 # Thinking chunks (qwen3 chain-of-thought, only when think=True)
                 thinking = msg.get("thinking", "")
                 if thinking:
+                    yielded_anything = True
                     yield ChatChunk(type="thinking", content=thinking)
 
                 # Content chunks
                 chunk = msg.get("content", "")
                 if chunk:
+                    yielded_anything = True
                     yield ChatChunk(type="content", content=chunk)
 
                 # Collect tool calls from any message (some models
@@ -246,13 +305,21 @@ async def stream_chat_with_tools(
                             len(accumulated_tool_calls),
                             json.dumps(accumulated_tool_calls)[:500],
                         )
+                        yielded_anything = True
                         yield ChatChunk(type="tool_calls", tool_calls=accumulated_tool_calls)
                     else:
                         logger.debug("Ollama done with no tool calls")
+                    eval_count = data.get("eval_count") or 0
+                    if not yielded_anything and eval_count > 0:
+                        logger.warning(
+                            "Ollama silent generation: model=%s eval_count=%d but no "
+                            "thinking/content/tool_calls were yielded. Last frames: %s",
+                            model, eval_count, recent_frames,
+                        )
                     yield ChatChunk(
                         type="done",
                         prompt_tokens=data.get("prompt_eval_count"),
-                        output_tokens=data.get("eval_count"),
+                        output_tokens=eval_count,
                     )
                     break
 
@@ -269,9 +336,17 @@ async def generate_completion(
     num_ctx overrides the model's context window for this call only.
     """
     last_exc: Exception | None = None
-    options: dict = {"num_predict": max_tokens}
-    if num_ctx is not None:
-        options["num_ctx"] = num_ctx
+    # Default num_ctx to Config.OLLAMA_NUM_CTX (matching stream_chat /
+    # stream_chat_with_tools). Without this, Ollama silently uses the model's
+    # default window (~4k on qwen3) and truncates anything longer. That is
+    # how the research pipeline's outline step kept falling back to a single
+    # monolith note: its 12-source prompt is ~6k tokens and was being chopped
+    # before the model ever saw it. Non-streaming callers must not inherit
+    # that footgun — if you truly want the model default, pass num_ctx=0.
+    options: dict = {
+        "num_predict": max_tokens,
+        "num_ctx": num_ctx if num_ctx is not None else Config.OLLAMA_NUM_CTX,
+    }
     for attempt in range(3):
         if attempt > 0:
             delay = 3.0 * attempt
@@ -289,7 +364,7 @@ async def generate_completion(
                         "stream": False,
                         "think": False,
                         "options": options,
-                        "keep_alive": "2h",
+                        "keep_alive": keep_alive_for(model),
                     },
                 )
                 resp.raise_for_status()
@@ -510,18 +585,29 @@ async def build_context(
     tool_lines = [
         "You have access to tool functions. You MUST use them when the user asks you to create, add, find, schedule, or search for anything.",
         "CRITICAL: Call the tool functions directly. NEVER write out function calls as text or code. NEVER describe what you would do — just do it.",
-        "Available actions: create_task, create_note, update_note, delete_note, delete_task, get_note, list_notes, list_tasks, search_notes.",
+        "GROUNDING: When the user asks about their own data — tasks, notes, events, projects, news, anything stored in this system — call the relevant tool to see what actually exists before answering. Never assert facts about the user's data from memory, prior context, or assumption. If you are unsure whether something exists, check with a tool.",
+        "HONESTY WHEN EMPTY: If a tool returns empty results (no matching tasks, no events in the date range, no search hits, no notes found), tell the user plainly that nothing matched. Do not fabricate example items, do not invent plausible-sounding meetings or deadlines to fill the response, and do not hedge with generic suggestions dressed up as real data. A direct 'you don't have anything on your calendar today' is always better than an invented event.",
+    ]
+    actions = [
+        "create_note (also creates tasks — set status='todo')", "update_note", "delete_note",
+        "read_note", "list_notes", "list_tasks", "log_work", "search_notes",
+        "create_project", "list_projects", "get_project", "update_project",
+        "search_projects", "create_milestone", "update_milestone", "list_milestones",
+        "save_person", "save_place", "create_list", "add_to_list", "clear_checked_items",
+        "set_rag_scope", "get_profile", "update_profile", "get_weather", "calculate",
+        "get_rss_items", "add_rss_feed", "read_article",
     ]
     if has_caldav:
-        tool_lines[-1] = (
-            "Available actions: create_task, create_note, update_note, delete_note, delete_task, get_note, list_notes, list_tasks, search_notes, "
-            "create_event, list_events, search_events, update_event, delete_event, list_calendars."
-        )
+        actions.extend(["create_event", "list_events", "search_events", "update_event", "delete_event", "list_calendars"])
         tool_lines.append(
             "For calendar events, use ISO 8601 datetime format with the user's timezone offset (stated in context below). "
             "Always include the UTC offset in datetime strings (e.g. 2026-09-30T14:00:00+01:00)."
         )
         tool_lines.append("When the user says 'remind me' with a time before an event, use the reminder_minutes parameter.")
+    actions.append("lookup")
+    if Config.searxng_enabled():
+        actions.extend(["research_topic", "search_images"])
+    tool_lines.append(f"Available actions: {', '.join(actions)}.")
     tool_lines.append(
         "For relative dates like 'Friday' or 'next week', resolve them to YYYY-MM-DD format. "
         "Always include the UTC offset when creating events (user's timezone is stated in context below)."
@@ -600,7 +686,7 @@ async def build_context(
                     f"\n\n--- Active Workspace ---\n"
                     f"You are in the \"{wp.title}\" project workspace.\n"
                     f"All notes and tasks you create or update MUST belong to this project.\n"
-                    f"Always pass project=\"{wp.title}\" when calling create_note or create_task.\n"
+                    f"Always pass project=\"{wp.title}\" when calling create_note.\n"
                     f"--- End Active Workspace ---"
                 )
         except Exception:
@@ -666,18 +752,27 @@ async def build_context(
     orphan_only = rag_project_id is None
     effective_project_id = rag_project_id if (rag_project_id is not None and rag_project_id != -1) else None
 
-    try:
-        from fabledassistant.services.embeddings import semantic_search_notes
-        for score, note in await semantic_search_notes(
-            user_id, user_message, exclude_ids=search_exclude or None, limit=8,
-            project_id=effective_project_id,
-            orphan_only=orphan_only,
-        ):
-            found_scored.append((score, note))
-    except Exception:
-        logger.warning("Semantic note search failed, falling back to keyword search", exc_info=True)
+    # Skip RAG auto-injection on the first turn of a seeded article discussion.
+    # The article body is already the sole context the user wants — pulling in
+    # unrelated orphan notes tricks the model into summarizing those instead.
+    # Follow-up turns keep RAG on because by then the user's own messages drive
+    # the query rather than the generic seed prompt.
+    from fabledassistant.services.article_context import ARTICLE_DISCUSS_SEED
+    _skip_rag_for_article_seed = user_message.strip() == ARTICLE_DISCUSS_SEED
 
-    if not found_scored:
+    if not _skip_rag_for_article_seed:
+        try:
+            from fabledassistant.services.embeddings import semantic_search_notes
+            for score, note in await semantic_search_notes(
+                user_id, user_message, exclude_ids=search_exclude or None, limit=8,
+                project_id=effective_project_id,
+                orphan_only=orphan_only,
+            ):
+                found_scored.append((score, note))
+        except Exception:
+            logger.warning("Semantic note search failed, falling back to keyword search", exc_info=True)
+
+    if not found_scored and not _skip_rag_for_article_seed:
         keywords = _extract_keywords(user_message)
         if keywords:
             try:
@@ -716,6 +811,8 @@ async def build_context(
                 "score": round(score, 2),
             })
         user_context_parts.append(
+            "[The following are reference excerpts from the user's personal notes, "
+            "not part of their message. Use them only if relevant to answering.]\n"
             "--- Relevant Notes ---\n"
             + "\n\n".join(snippets)
             + "\n--- End Relevant Notes ---"
@@ -756,33 +853,6 @@ async def build_context(
                 + "\n--- End Included Notes ---"
             )
 
-    # Semantically relevant RSS news items
-    try:
-        from fabledassistant.services.embeddings import get_embedding, semantic_search_rss_items
-        news_query_vec = await get_embedding(user_message)
-        news_hits = await semantic_search_rss_items(user_id, news_query_vec)
-        if news_hits:
-            news_snippets = []
-            for score, rss_item in news_hits:
-                feed_title = getattr(rss_item, "feed_title", "") or ""
-                excerpt = (rss_item.content or "")[:500].strip()
-                news_snippets.append(
-                    f"[{feed_title or 'News'}] {rss_item.title} (relevance: {round(score * 100)}%)\n"
-                    + (f"{excerpt}\n" if excerpt else "")
-                    + f"URL: {rss_item.url}"
-                )
-            user_context_parts.append(
-                "--- Recent News You've Seen ---\n"
-                + "\n\n".join(news_snippets)
-                + "\n--- End Recent News ---"
-            )
-            context_meta["rss_news"] = [
-                {"id": item.id, "title": item.title, "score": round(score, 2)}
-                for score, item in news_hits
-            ]
-    except Exception:
-        logger.debug("RSS semantic search skipped", exc_info=True)
-
     # URL content fetched from links in the user message
     urls = _find_urls(user_message)
     for url in urls[:2]:

src/fabledassistant/services/notes.py

@@ -22,6 +22,22 @@ def _normalize_tags(tags: list[str]) -> list[str]:
     return out
 
 
+async def _maybe_reactivate_project(project_id: int) -> None:
+    """If a project is paused, reactivate it — activity indicates resumed work."""
+    from fabledassistant.models.project import Project
+    try:
+        async with async_session() as session:
+            project = (await session.execute(
+                select(Project).where(Project.id == project_id)
+            )).scalars().first()
+            if project and project.status == "paused":
+                project.status = "active"
+                await session.commit()
+                logger.info("Auto-reactivated paused project %d (%s)", project_id, project.title)
+    except Exception:
+        logger.debug("_maybe_reactivate_project failed for project %d", project_id, exc_info=True)
+
+
 async def _maybe_trigger_project_summary(user_id: int, project_id: int) -> None:
     """Fire generate_project_summary() if the project summary is missing or >1h old."""
     import asyncio
@@ -92,6 +108,7 @@ async def create_note(
         await session.refresh(note)
 
     if project_id is not None:
+        await _maybe_reactivate_project(project_id)
         await _maybe_trigger_project_summary(user_id, project_id)
 
     return note
@@ -119,6 +136,7 @@ async def list_notes(
     milestone_ids: list[int] | None = None,
     parent_id: int | None = None,
     no_project: bool = False,
+    exclude_paused_projects: bool = False,
     sort: str = "updated_at",
     order: str = "desc",
     limit: int = 50,
@@ -194,6 +212,17 @@ async def list_notes(
             query = query.where(Note.project_id.is_(None))
             count_query = count_query.where(Note.project_id.is_(None))
 
+        if exclude_paused_projects:
+            from fabledassistant.models.project import Project
+            paused_ids = (
+                select(Project.id)
+                .where(Project.user_id == user_id, Project.status == "paused")
+                .scalar_subquery()
+            )
+            paused_filter = or_(Note.project_id.is_(None), Note.project_id.not_in(paused_ids))
+            query = query.where(paused_filter)
+            count_query = count_query.where(paused_filter)
+
         sort_col = getattr(Note, sort, Note.updated_at)
         if order == "asc":
             query = query.order_by(sort_col.asc())
@@ -284,6 +313,7 @@ async def update_note(user_id: int, note_id: int, **fields: object) -> Note | No
         await create_version(user_id, note_id, old_body, old_title, old_tags)
 
     if note.project_id is not None:
+        await _maybe_reactivate_project(note.project_id)
         await _maybe_trigger_project_summary(user_id, note.project_id)
 
     return note

src/fabledassistant/services/notifications.py

@@ -103,7 +103,7 @@ async def send_password_reset_email(email: str, reset_url: str) -> None:
             We received a request to reset your password. Click the button below to choose a new password.
         </p>
         <div style="text-align:center;margin:24px 0;">
-            <a href="{reset_url}" style="display:inline-block;background:#6366f1;color:#ffffff;padding:12px 32px;border-radius:6px;text-decoration:none;font-weight:600;font-size:15px;">
+            <a href="{reset_url}" style="display:inline-block;background:#7c3aed;color:#ffffff;padding:12px 32px;border-radius:6px;text-decoration:none;font-weight:600;font-size:15px;">
                 Reset Password
             </a>
         </div>
@@ -136,7 +136,7 @@ async def send_invitation_email(email: str, invite_url: str, invited_by_username
             Click the button below to create your account.
         </p>
         <div style="text-align:center;margin:24px 0;">
-            <a href="{invite_url}" style="display:inline-block;background:#6366f1;color:#ffffff;padding:12px 32px;border-radius:6px;text-decoration:none;font-weight:600;font-size:15px;">
+            <a href="{invite_url}" style="display:inline-block;background:#7c3aed;color:#ffffff;padding:12px 32px;border-radius:6px;text-decoration:none;font-weight:600;font-size:15px;">
                 Accept Invitation
             </a>
         </div>

src/fabledassistant/services/projects.py

@@ -141,13 +141,30 @@ async def generate_project_summary(user_id: int, project_id: int) -> None:
         logger.debug("Failed to generate summary for project %d", project_id, exc_info=True)
 
 
+# Cutoff: summaries older than this were generated by qwen2.5:3b, which
+# produced broken output (token repetition, hallucinated topics, misspellings).
+# Anything stamped before the switch to gemma3:4b on 2026-04-12 gets
+# regenerated at startup so the whole project list ends up on the better model.
+_BACKGROUND_MODEL_CUTOVER = datetime(2026, 4, 12, tzinfo=timezone.utc)
+
+
 async def backfill_project_summaries() -> None:
-    """Generate summaries for all projects missing auto_summary. Fire-and-forget."""
+    """Generate summaries for projects missing or predating the gemma3:4b cutover.
+
+    Fire-and-forget: each summary runs as its own background task.
+    """
     import asyncio
+    from sqlalchemy import or_
     try:
         async with async_session() as session:
             rows = (await session.execute(
-                select(Project.id, Project.user_id).where(Project.auto_summary.is_(None))
+                select(Project.id, Project.user_id).where(
+                    or_(
+                        Project.auto_summary.is_(None),
+                        Project.summary_updated_at.is_(None),
+                        Project.summary_updated_at < _BACKGROUND_MODEL_CUTOVER,
+                    )
+                )
             )).all()
         for row in rows:
             asyncio.create_task(generate_project_summary(row.user_id, row.id))

src/fabledassistant/services/research.py

@@ -9,7 +9,8 @@ import httpx
 
 from fabledassistant.config import Config
 from fabledassistant.services.llm import fetch_url_content, generate_completion, stream_chat
-from fabledassistant.services.notes import create_note
+from fabledassistant.services.notes import create_note, update_note
+from fabledassistant.services.wikipedia import wiki_search
 from fabledassistant.models.note import Note
 
 logger = logging.getLogger(__name__)
@@ -35,8 +36,8 @@ def _build_sources_block(sources: list[dict]) -> str:
 async def _generate_outline(topic: str, sources: list[dict], model: str) -> list[dict]:
     """Generate a topic outline from fetched research sources.
 
-    Returns a list of {"title": str, "focus": str} dicts (3–8 entries).
-    Returns [] on failure — callers must fall back to single-note synthesis.
+    Returns a list of {"title": str, "focus": str} dicts (2–8 entries).
+    Retries once on failure before returning [] (callers fall back to single-note).
     """
     import json as _json
 
@@ -61,23 +62,37 @@ async def _generate_outline(topic: str, sources: list[dict], model: str) -> list
             "content": f"Topic: {topic}\n\nSources:\n{sources_block}",
         },
     ]
-    try:
-        raw = await generate_completion(messages, model, max_tokens=400)
-        raw = raw.strip()
-        raw = re.sub(r"^```(?:json)?\s*", "", raw)
-        raw = re.sub(r"\s*```$", "", raw)
-        idx = raw.find("[")
-        if idx >= 0:
-            parsed, _ = _json.JSONDecoder().raw_decode(raw[idx:])
-            if isinstance(parsed, list):
-                sections = [
-                    s for s in parsed
-                    if isinstance(s, dict) and s.get("title") and s.get("focus")
-                ]
-                if len(sections) >= 3:
-                    return sections[:8]
-    except Exception:
-        logger.warning("Outline generation failed for topic '%s'", topic, exc_info=True)
+    for attempt in range(2):
+        try:
+            # Pin num_ctx explicitly. The prompt carries up to 12 sources at
+            # 2000 chars each (~6k tokens of source material alone) plus the
+            # system prompt — well over Ollama's default model window on
+            # qwen3. Without this, Ollama silently truncates the prompt, the
+            # model can't see most of the sources, JSON parsing fails twice,
+            # and the pipeline falls back to a single monolith note
+            # (`research.py:251`). Do not remove even if `generate_completion`
+            # appears to default this — see the comment there.
+            raw = await generate_completion(
+                messages, model, max_tokens=400, num_ctx=16384
+            )
+            raw = raw.strip()
+            raw = re.sub(r"^```(?:json)?\s*", "", raw)
+            raw = re.sub(r"\s*```$", "", raw)
+            idx = raw.find("[")
+            if idx >= 0:
+                parsed, _ = _json.JSONDecoder().raw_decode(raw[idx:])
+                if isinstance(parsed, list):
+                    sections = [
+                        s for s in parsed
+                        if isinstance(s, dict) and s.get("title") and s.get("focus")
+                    ]
+                    if len(sections) >= 2:
+                        return sections[:8]
+        except Exception:
+            logger.warning(
+                "Outline generation attempt %d failed for topic '%s'",
+                attempt + 1, topic, exc_info=True,
+            )
     return []
 
 
@@ -121,6 +136,55 @@ async def _synthesize_section(
     return section_title, raw.strip()
 
 
+async def _generate_executive_summary(
+    topic: str,
+    section_bodies: list[tuple[str, str]],
+    model: str,
+) -> str:
+    """Generate a 2-3 paragraph executive summary from completed section notes.
+
+    Args:
+        section_bodies: list of (title, body) pairs from the section notes.
+
+    Returns summary markdown (no heading — caller adds structure).
+    """
+    sections_block = "\n\n".join(
+        f"### {title}\n{body[:1500]}" for title, body in section_bodies
+    )
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a research summarizer. Given several completed research sections on a topic, "
+                "write a concise executive summary.\n\n"
+                "Requirements:\n"
+                "- 2–3 paragraphs of substantive prose (150–300 words total)\n"
+                "- Cover the key findings and insights across all sections\n"
+                "- Highlight the most important or surprising takeaways\n"
+                "- Write so someone can decide which sections to read in detail\n"
+                "- Do NOT include headings, bullet points, or source citations\n"
+                "- Do NOT start with 'This research' or 'This document' — jump straight into the content"
+            ),
+        },
+        {
+            "role": "user",
+            "content": f"Topic: {topic}\n\nSections:\n{sections_block}",
+        },
+    ]
+    try:
+        # Pin num_ctx explicitly — see `_generate_outline` comment for the
+        # rationale. This prompt carries N sections × 1500 chars of section
+        # prose, which can easily exceed the default model window. Don't
+        # trust the `generate_completion` default to stick.
+        raw = await generate_completion(
+            messages, model, max_tokens=600, num_ctx=16384
+        )
+        return raw.strip()
+    except Exception:
+        logger.warning("Executive summary generation failed for '%s'", topic, exc_info=True)
+        return ""
+
+
 async def run_research_pipeline(
     topic: str,
     user_id: int,
@@ -142,7 +206,7 @@ async def run_research_pipeline(
     queries = await _generate_sub_queries(topic, model)
     logger.info("Research: generated %d sub-queries for topic '%s'", len(queries), topic)
 
-    # Step 2: Search all queries in parallel (200 ms stagger to avoid hammering SearXNG)
+    # Step 2: Search all queries in parallel (SearXNG + Wikipedia)
     async def _search_with_stagger(i: int, query: str) -> tuple[str, list[dict]]:
         if i > 0:
             await asyncio.sleep(0.2 * i)
@@ -151,13 +215,22 @@ async def run_research_pipeline(
         logger.info("Research: query '%s' → %d results", query, len(results))
         return query, results
 
-    search_results = await asyncio.gather(
+    async def _wiki_for_query(query: str) -> list[dict]:
+        return await wiki_search(query, limit=1)
+
+    searxng_task = asyncio.gather(
         *[_search_with_stagger(i, q) for i, q in enumerate(queries)]
     )
+    wiki_task = asyncio.gather(
+        *[_wiki_for_query(q) for q in queries]
+    )
+    search_results, wiki_results = await asyncio.gather(searxng_task, wiki_task)
 
     # Deduplicate URLs across all queries
     seen_urls: set[str] = set()
     url_tasks: list[tuple[str, dict, str]] = []  # (url, result_dict, query)
+    wiki_sources: list[dict] = []  # Wikipedia articles (already have content)
+
     for query, results in search_results:
         for result in results[:PAGES_PER_QUERY]:
             url = result.get("url", "")
@@ -165,7 +238,21 @@ async def run_research_pipeline(
                 seen_urls.add(url)
                 url_tasks.append((url, result, query))
 
-    # Fetch all unique URLs in parallel
+    # Add Wikipedia results (they already have content via extract)
+    for query, wiki_hits in zip(queries, wiki_results):
+        for hit in wiki_hits:
+            url = hit.get("url", "")
+            if url and url not in seen_urls:
+                seen_urls.add(url)
+                wiki_sources.append({
+                    "url": url,
+                    "title": hit["title"],
+                    "query": query,
+                    "snippet": hit["extract"][:200],
+                    "content": hit["extract"],
+                })
+
+    # Fetch all unique SearXNG URLs in parallel
     async def _fetch_source(url: str, result: dict, query: str) -> dict:
         title = result.get("title", url)
         _status(f"Reading: {title[:60]}...")
@@ -178,10 +265,12 @@ async def run_research_pipeline(
             "content": content,
         }
 
-    all_sources: list[dict] = list(await asyncio.gather(
+    fetched_sources: list[dict] = list(await asyncio.gather(
         *[_fetch_source(url, result, query) for url, result, query in url_tasks]
     ))
 
+    all_sources = wiki_sources + fetched_sources
+
     if not all_sources:
         raise ValueError(f"No results found for '{topic}'")
 
@@ -220,28 +309,17 @@ async def run_research_pipeline(
         return_exceptions=True,
     )
 
-    # Step 5: Create section notes sequentially
-    _status(f"Saving {len(outline)} notes...")
-    section_note_pairs: list[tuple[dict, Note]] = []
+    # Collect successful results for index + summary generation
+    section_results: list[tuple[dict, str, str]] = []  # (outline_entry, title, body)
     for section, result in zip(outline, raw_results):
         if isinstance(result, Exception):
             logger.warning("Section synthesis failed for '%s': %s", section["title"], result)
             continue
         sec_title, sec_body = result
-        try:
-            note = await create_note(
-                user_id=user_id,
-                title=sec_title,
-                body=sec_body,
-                tags=["research"],
-                project_id=project_id,
-            )
-            section_note_pairs.append((section, note))
-        except Exception:
-            logger.warning("Failed to save section note '%s'", sec_title, exc_info=True)
+        section_results.append((section, sec_title, sec_body))
 
     # All sections failed — fall back to single note
-    if not section_note_pairs:
+    if not section_results:
         logger.warning("All section syntheses failed, falling back to single note for '%s'", topic)
         _status("Synthesizing report (fallback)...")
         title, body = await _synthesize_note(topic, synthesis_sources, model, buf=None)
@@ -250,20 +328,24 @@ async def run_research_pipeline(
         )
         return note
 
-    # Step 6: Create index note
+    # Step 5: Generate executive summary from section content
+    _status("Writing summary...")
+    executive_summary = await _generate_executive_summary(
+        topic, [(t, b) for _, t, b in section_results], model,
+    )
+
+    # Step 6: Create index note first (so section notes can reference it via parent_id)
     from datetime import date as _date
     index_lines = [
         f"Research overview for **{topic}** — {_date.today().isoformat()}",
         "",
-        f"Generated from {len(synthesis_sources)} web sources across {len(section_note_pairs)} sections.",
-        "",
-        "## Sections",
+        f"Generated from {len(synthesis_sources)} web sources across {len(section_results)} sections.",
         "",
     ]
-    for section, note in section_note_pairs:
-        index_lines.append(f"- **{note.title}** — {section['focus']}")
-    index_lines += ["", "*Search for any section title to read it.*"]
-
+    if executive_summary:
+        index_lines += ["## Summary", "", executive_summary, ""]
+    index_lines += ["## Sections", ""]
+    # Placeholder — will be updated with real links after section notes are created
     index_note = await create_note(
         user_id=user_id,
         title=f"Research: {topic}",
@@ -271,6 +353,34 @@ async def run_research_pipeline(
         tags=["research", "research-index"],
         project_id=project_id,
     )
+
+    # Step 7: Create section notes with parent_id pointing to index
+    _status(f"Saving {len(section_results)} notes...")
+    section_note_pairs: list[tuple[dict, Note]] = []
+    for section, sec_title, sec_body in section_results:
+        try:
+            note = await create_note(
+                user_id=user_id,
+                title=sec_title,
+                body=sec_body,
+                tags=["research"],
+                project_id=project_id,
+                parent_id=index_note.id,
+            )
+            section_note_pairs.append((section, note))
+        except Exception:
+            logger.warning("Failed to save section note '%s'", sec_title, exc_info=True)
+
+    # Step 8: Update index note body with real links to section notes
+    for section, note in section_note_pairs:
+        index_lines.append(f"- [{note.title}](/notes/{note.id}) — {section['focus']}")
+
+    await update_note(
+        user_id=user_id,
+        note_id=index_note.id,
+        body="\n".join(index_lines),
+    )
+
     logger.info(
         "Research: created %d section notes + index id=%d for topic '%s'",
         len(section_note_pairs), index_note.id, topic,

src/fabledassistant/services/rss.py

@@ -34,6 +34,34 @@ def _html_to_text(html: str) -> str:
         return html
 
 
+async def get_or_fetch_full_article(item: RssItem) -> str | None:
+    """Return the full article body, fetching+caching on miss.
+
+    Checks ``item.content_full`` first — populated either by the enrichment
+    pass at feed-ingest time or by a previous discuss-click. On miss, fetches
+    via ``_fetch_full_article`` and writes through. Returns ``None`` only if
+    the fetch itself fails; ``item.content_full == ""`` is still a cache hit.
+
+    Callers must pass an RssItem attached to an open session if they want
+    the write-through to persist — otherwise the fetched text is returned
+    but the cache stays empty and the next click will re-fetch.
+    """
+    if item.content_full is not None:
+        return item.content_full
+    if not item.url:
+        return None
+    text = await _fetch_full_article(item.url)
+    if text is None:
+        return None
+    async with async_session() as session:
+        fresh = await session.get(RssItem, item.id)
+        if fresh is not None:
+            fresh.content_full = text
+            fresh.content_fetched_at = datetime.now(timezone.utc)
+            await session.commit()
+    return text
+
+
 async def _fetch_full_article(url: str) -> str | None:
     """Fetch a URL and extract its main article text via trafilatura.
 
@@ -209,6 +237,11 @@ async def fetch_and_cache_feed(feed_id: int, url: str) -> int:
                         item = await session.get(RssItem, item_id)
                         if item:
                             item.content = full_text
+                            # Populate the discuss-click cache too so the
+                            # first click skips straight to the map-reduce
+                            # step without re-fetching.
+                            item.content_full = full_text
+                            item.content_fetched_at = datetime.now(timezone.utc)
                             await session.commit()
                             await upsert_rss_item_embedding(
                                 item_id, feed_user_id, item.title or "", item.content

src/fabledassistant/services/tools/__init__.py

@@ -0,0 +1,33 @@
+"""Tool registry package.
+
+Importing this package loads all tool modules (triggering ``@tool``
+decorator registration) and re-exports the public API that the rest
+of the app depends on.
+"""
+
+# Import every tool module so their @tool decorators run at import time.
+# Order does not matter — registration is additive.
+from fabledassistant.services.tools import (  # noqa: F401
+    calendar,
+    entities,
+    notes,
+    profile,
+    projects,
+    rag,
+    rss,
+    tasks,
+    utility,
+    weather,
+    web,
+)
+from fabledassistant.services.tools._registry import (
+    execute_tool,
+    get_briefing_tools,
+    get_tools_for_user,
+)
+
+__all__ = [
+    "execute_tool",
+    "get_briefing_tools",
+    "get_tools_for_user",
+]

src/fabledassistant/services/tools/_helpers.py

@@ -0,0 +1,124 @@
+"""Shared utilities used across tool modules."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from datetime import date, datetime
+from difflib import SequenceMatcher
+
+logger = logging.getLogger(__name__)
+
+_PUNCT_RE = re.compile(r"[^\w\s]")
+
+
+def schedule_embedding(note_id: int, user_id: int, title: str, body: str) -> None:
+    """Fire-and-forget: update the embedding for a note after it's created/modified."""
+    from fabledassistant.services.embeddings import upsert_note_embedding
+
+    text = f"{title}\n{body}".strip() if body else (title or "")
+    if text:
+        asyncio.create_task(upsert_note_embedding(note_id, user_id, text))
+
+
+async def resolve_project(user_id: int, project_name: str):
+    """Exact-then-fuzzy project lookup. Returns the Project or None.
+
+    Resolution order:
+    1. Exact title match (case-insensitive via DB)
+    2. project_name is a substring of an existing title
+    3. Existing title is a substring of project_name
+    4. SequenceMatcher ratio >= 0.55
+    """
+    from fabledassistant.services.projects import get_project_by_title, list_projects
+
+    proj = await get_project_by_title(user_id, project_name)
+    if proj is not None:
+        return proj
+    needle = project_name.lower().strip()
+    all_p = await list_projects(user_id)
+    for p in all_p:
+        haystack = p.title.lower().strip()
+        if needle in haystack or haystack in needle:
+            return p
+    best, best_r = None, 0.0
+    for p in all_p:
+        r = SequenceMatcher(None, needle, p.title.lower().strip()).ratio()
+        if r >= 0.55 and r > best_r:
+            best, best_r = p, r
+    return best
+
+
+def parse_due_date(value: str | None) -> date | None:
+    """Parse a due date string, returning None on failure."""
+    if not value:
+        return None
+    try:
+        return datetime.strptime(value, "%Y-%m-%d").date()
+    except (ValueError, TypeError):
+        logger.warning("Invalid due_date format: %s", value)
+        return None
+
+
+def fuzzy_title_match(title: str, candidates, threshold: float = 0.82):
+    """Return (best_match, ratio) if any candidate's title is similar enough.
+
+    Uses SequenceMatcher ratio. Threshold 0.82 catches near-duplicates like
+    "Game Premise" / "Game Premise Notes" while leaving clearly different
+    titles alone. Returns (None, 0.0) when no candidate meets the threshold.
+    """
+    needle = title.lower().strip()
+    best, best_r = None, 0.0
+    for c in candidates:
+        r = SequenceMatcher(None, needle, c.title.lower().strip()).ratio()
+        if r >= threshold and r > best_r:
+            best, best_r = c, r
+    return best, best_r
+
+
+async def check_duplicate(
+    user_id: int,
+    title: str,
+    body: str,
+    is_task: bool,
+    confirmed: bool,
+) -> dict | None:
+    """Check for exact, fuzzy, and semantic duplicates. Returns error dict or None."""
+    from fabledassistant.services.notes import list_notes
+
+    item_label = "task" if is_task else "note"
+
+    existing, _ = await list_notes(user_id=user_id, q=title, is_task=is_task, limit=1)
+    exact = next((n for n in existing if n.title.lower() == title.lower()), None)
+    if exact is not None:
+        return {
+            "success": False,
+            "error": f"A {item_label} titled '{title}' already exists (id: {exact.id}). Use update_note to modify it instead of creating a duplicate.",
+        }
+
+    clean_q = _PUNCT_RE.sub(" ", title).strip()
+    candidates, _ = await list_notes(user_id=user_id, q=clean_q, is_task=is_task, limit=20)
+    near, ratio = fuzzy_title_match(title, candidates)
+    if near is not None:
+        return {
+            "success": False,
+            "requires_confirmation": True,
+            "similar_note": {"id": near.id, "title": near.title},
+            "error": f"A {item_label} with a very similar title '{near.title}' already exists (similarity: {ratio:.0%}). Ask the user to confirm before creating a separate entry.",
+        }
+
+    if not confirmed and len(body.strip()) >= 80:
+        from fabledassistant.services.embeddings import semantic_search_notes as _ssn
+        sem_query = f"{title}\n{body}".strip()
+        sem_hits = await _ssn(user_id, sem_query, limit=3, threshold=0.90, is_task=is_task)
+        if sem_hits:
+            best_score, best_note = sem_hits[0]
+            return {
+                "success": False,
+                "requires_confirmation": True,
+                "similar_note": {"id": best_note.id, "title": best_note.title},
+                "error": f"A {item_label} with very similar content exists: '{best_note.title}' (semantic similarity: {best_score:.0%}). Ask the user to confirm before creating a separate entry.",
+            }
+
+    return None

src/fabledassistant/services/tools/_registry.py

@@ -0,0 +1,136 @@
+"""Decorator-based tool registry.
+
+Each tool is registered via ``@tool(...)`` which captures the OpenAI-style
+function schema and handler in one place.  ``get_tools_for_user`` and
+``execute_tool`` are the public API consumed by the rest of the app.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Callable, Coroutine
+
+from fabledassistant.config import Config
+from fabledassistant.services.caldav import is_caldav_configured
+
+logger = logging.getLogger(__name__)
+
+type ToolHandler = Callable[..., Coroutine[Any, Any, dict]]
+
+
+@dataclass(frozen=True, slots=True)
+class ToolDef:
+    name: str
+    description: str
+    parameters: dict
+    handler: ToolHandler
+    read_only: bool = False
+    briefing: bool = False
+    requires: str | None = None
+    required_params: list[str] = field(default_factory=list)
+
+    def schema(self) -> dict:
+        """Return the OpenAI function-calling schema dict."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": self.parameters,
+                    **({"required": self.required_params} if self.required_params else {}),
+                },
+            },
+        }
+
+
+_REGISTRY: dict[str, ToolDef] = {}
+
+
+def tool(
+    *,
+    name: str,
+    description: str,
+    parameters: dict | None = None,
+    required: list[str] | None = None,
+    read_only: bool = False,
+    briefing: bool = False,
+    requires: str | None = None,
+) -> Callable[[ToolHandler], ToolHandler]:
+    """Register an async tool handler with its schema metadata."""
+
+    def decorator(fn: ToolHandler) -> ToolHandler:
+        if name in _REGISTRY:
+            raise ValueError(f"Duplicate tool registration: {name}")
+        _REGISTRY[name] = ToolDef(
+            name=name,
+            description=description,
+            parameters=parameters or {},
+            handler=fn,
+            read_only=read_only,
+            briefing=briefing,
+            requires=requires,
+            required_params=required or [],
+        )
+        return fn
+
+    return decorator
+
+
+async def _check_requires(user_id: int, requires: str) -> bool:
+    if requires == "caldav":
+        return await is_caldav_configured(user_id)
+    if requires == "searxng":
+        return Config.searxng_enabled()
+    if requires == "rss":
+        from fabledassistant.services.settings import get_setting
+        return (await get_setting(user_id, "rss_enabled", "false")).lower() == "true"
+    return True
+
+
+async def get_tools_for_user(user_id: int) -> list[dict]:
+    """Build the tool schema list for a user based on configured integrations."""
+    tools: list[dict] = []
+    for td in _REGISTRY.values():
+        if td.requires and not await _check_requires(user_id, td.requires):
+            continue
+        tools.append(td.schema())
+    logger.debug("User %d: %d tools available", user_id, len(tools))
+    return tools
+
+
+async def get_briefing_tools(user_id: int) -> list[dict]:
+    """Return only the tool schemas marked ``briefing=True``."""
+    all_tools = await get_tools_for_user(user_id)
+    names = {td.name for td in _REGISTRY.values() if td.briefing}
+    filtered = [t for t in all_tools if t["function"]["name"] in names]
+    logger.debug(
+        "Briefing tools for user %d: %d of %d selected",
+        user_id, len(filtered), len(all_tools),
+    )
+    return filtered
+
+
+async def execute_tool(
+    user_id: int,
+    tool_name: str,
+    arguments: dict,
+    conv_id: int | None = None,
+    workspace_project_id: int | None = None,
+) -> dict:
+    """Execute a tool call and return the result."""
+    td = _REGISTRY.get(tool_name)
+    if td is None:
+        return {"success": False, "error": f"Unknown tool: {tool_name}"}
+    try:
+        return await td.handler(
+            user_id=user_id,
+            arguments=arguments,
+            conv_id=conv_id,
+            workspace_project_id=workspace_project_id,
+        )
+    except Exception as e:
+        logger.exception("Tool execution failed: %s", tool_name)
+        return {"success": False, "error": str(e)}

src/fabledassistant/services/tools/calendar.py

@@ -0,0 +1,250 @@
+"""Calendar and event tools."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from fabledassistant.services.events import (
+    create_event as events_create_event,
+    delete_event as events_delete_event,
+    find_events_by_query,
+    list_events as events_list_events,
+    search_events as events_search_events,
+    update_event as events_update_event,
+)
+from fabledassistant.services.tools._helpers import resolve_project
+from fabledassistant.services.tools._registry import tool
+from fabledassistant.services.tz import get_user_tz
+
+
+async def _parse_datetime_in_user_tz(
+    user_id: int, value: str
+) -> tuple[datetime, bool]:
+    """Parse a date/datetime string from the model into a UTC-aware datetime.
+
+    Naive inputs are interpreted in the **user's local timezone** and then
+    converted to UTC for storage. Never default to UTC for naive inputs —
+    that's how all-day events landed on the wrong day for non-UTC users.
+
+    Returns ``(utc_datetime, was_date_only)``.
+    """
+    was_date_only = "T" not in value and " " not in value
+    if was_date_only:
+        value = f"{value}T00:00:00"
+    dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    if dt.tzinfo is None:
+        user_tz = await get_user_tz(user_id)
+        dt = dt.replace(tzinfo=user_tz)
+    return dt.astimezone(timezone.utc), was_date_only
+
+
+@tool(
+    name="create_event",
+    description="Create a calendar event for the user. Use this when the user asks to schedule, add, or create a meeting, appointment, or event. Pass dates and datetimes in the user's local time — a bare date like '2026-09-30' is interpreted as that day in the user's configured timezone.",
+    parameters={
+        "title": {"type": "string", "description": "A descriptive event title"},
+        "start": {"type": "string", "description": "Start date (YYYY-MM-DD) or datetime (YYYY-MM-DDTHH:MM) in the user's local time. Include a timezone offset only if the user explicitly mentions one."},
+        "end": {"type": "string", "description": "Optional end date or datetime in the user's local time"},
+        "duration": {"type": "integer", "description": "Optional duration in minutes (default 60, ignored if end is set or all_day is true)"},
+        "description": {"type": "string", "description": "Optional event description"},
+        "location": {"type": "string", "description": "Optional event location"},
+        "color": {"type": "string", "description": "Optional hex color for the event (e.g. '#6366f1')"},
+        "all_day": {"type": "boolean", "description": "True for all-day events (birthdays, holidays, deadlines)"},
+        "recurrence": {"type": "string", "description": "Optional iCalendar RRULE (e.g. 'FREQ=YEARLY' for annual, 'FREQ=WEEKLY' for weekly, 'FREQ=MONTHLY' for monthly)"},
+        "reminder_minutes": {"type": "integer", "description": "Optional reminder N minutes before the event (e.g. 30 for 30 minutes before)"},
+        "attendees": {"type": "array", "items": {"type": "string"}, "description": "Optional list of attendee email addresses"},
+        "calendar_name": {"type": "string", "description": "Optional calendar name to create the event in. Falls back to default calendar."},
+        "project": {"type": "string", "description": "Optional project name to associate this event with"},
+    },
+    required=["title", "start"],
+)
+async def create_event_tool(*, user_id, arguments, **_ctx):
+    start_str = arguments["start"]
+    end_str = arguments.get("end")
+    all_day = arguments.get("all_day", False)
+    try:
+        # Naive dates/datetimes are interpreted in the user's local
+        # timezone, not UTC. Storing UTC for naive inputs caused all-day
+        # events to land on the previous day for negative-offset users.
+        start_dt, start_was_date_only = await _parse_datetime_in_user_tz(
+            user_id, start_str
+        )
+    except (ValueError, TypeError):
+        return {"success": False, "error": f"Invalid start datetime: {start_str!r}"}
+    if start_was_date_only:
+        all_day = True
+    end_dt = None
+    if end_str:
+        try:
+            end_dt, _ = await _parse_datetime_in_user_tz(user_id, end_str)
+        except (ValueError, TypeError):
+            return {"success": False, "error": f"Invalid end datetime: {end_str!r}"}
+    project_id = None
+    project_name = arguments.get("project")
+    if project_name:
+        proj = await resolve_project(user_id, project_name)
+        if proj:
+            project_id = proj.id
+    event = await events_create_event(
+        user_id=user_id,
+        title=arguments.get("title", "Untitled Event"),
+        start_dt=start_dt,
+        end_dt=end_dt,
+        all_day=all_day,
+        description=arguments.get("description") or "",
+        location=arguments.get("location") or "",
+        color=arguments.get("color") or "",
+        recurrence=arguments.get("recurrence"),
+        project_id=project_id,
+        duration=arguments.get("duration"),
+        reminder_minutes=arguments.get("reminder_minutes"),
+        attendees=arguments.get("attendees"),
+        calendar_name=arguments.get("calendar_name"),
+    )
+    return {"success": True, "type": "event", "data": event.to_dict()}
+
+
+@tool(
+    name="list_events",
+    description="List calendar events in a date range. Use this when the user asks what events or meetings they have. Pass plain local dates (YYYY-MM-DD) — the server interprets them in the user's timezone and expands to a full local day.",
+    parameters={
+        "date_from": {"type": "string", "description": "Start of range as a local date (YYYY-MM-DD) or local datetime. Interpreted in the user's timezone."},
+        "date_to": {"type": "string", "description": "End of range as a local date (YYYY-MM-DD) or local datetime. A bare date is expanded to 23:59:59 local."},
+    },
+    required=["date_from", "date_to"],
+    read_only=True,
+    briefing=True,
+)
+async def list_events_tool(*, user_id, arguments, **_ctx):
+    # Bare local dates are expanded to a full local day in the user's TZ:
+    # date_from → 00:00 local, date_to → 23:59:59 local, both converted to
+    # UTC before the DB query. Previously the tool description told the
+    # model to pass UTC ranges, which missed events for non-UTC users.
+    try:
+        date_from, _ = await _parse_datetime_in_user_tz(
+            user_id, arguments["date_from"]
+        )
+        date_to_str = arguments["date_to"]
+        if "T" not in date_to_str and " " not in date_to_str:
+            date_to_str = f"{date_to_str}T23:59:59"
+        date_to, _ = await _parse_datetime_in_user_tz(user_id, date_to_str)
+    except (ValueError, TypeError, KeyError) as exc:
+        return {"success": False, "error": f"Invalid date range: {exc}"}
+    events = await events_list_events(user_id=user_id, date_from=date_from, date_to=date_to)
+    return {
+        "success": True,
+        "type": "events",
+        "data": {"count": len(events), "events": events},
+    }
+
+
+@tool(
+    name="search_events",
+    description="Search calendar events by keyword. Use this when the user asks to find a specific event or meeting.",
+    parameters={
+        "query": {"type": "string", "description": "Search keyword to match against event titles, locations, and descriptions"},
+        "include_past": {"type": "boolean", "description": "Set to true to include past events in results (default: future events only)"},
+    },
+    required=["query"],
+    read_only=True,
+    briefing=True,
+)
+async def search_events_tool(*, user_id, arguments, **_ctx):
+    events = await events_search_events(
+        user_id=user_id,
+        query=arguments.get("query", ""),
+        include_past=arguments.get("include_past", False),
+    )
+    return {
+        "success": True,
+        "type": "events",
+        "data": {
+            "query": arguments.get("query", ""),
+            "count": len(events),
+            "events": [e.to_dict() for e in events],
+        },
+    }
+
+
+@tool(
+    name="update_event",
+    description="Update an existing calendar event. Use this when the user asks to change, move, reschedule, or modify an event.",
+    parameters={
+        "query": {"type": "string", "description": "Search term to find the event to update (matches against title)"},
+        "title": {"type": "string", "description": "New title for the event"},
+        "start": {"type": "string", "description": "New start datetime in ISO 8601 format"},
+        "end": {"type": "string", "description": "New end datetime in ISO 8601 format"},
+        "all_day": {"type": "boolean", "description": "Whether the event is all-day"},
+        "description": {"type": "string", "description": "New event description"},
+        "location": {"type": "string", "description": "New event location"},
+        "color": {"type": "string", "description": "New hex color for the event (e.g. '#6366f1')"},
+        "recurrence": {"type": "string", "description": "New iCalendar RRULE"},
+        "reminder_minutes": {"type": "integer", "description": "Reminder N minutes before the event. Pass 0 to remove an existing reminder."},
+    },
+    required=["query"],
+)
+async def update_event_tool(*, user_id, arguments, **_ctx):
+    query = arguments.get("query", "")
+    matches = await find_events_by_query(user_id=user_id, query=query)
+    if not matches:
+        return {"success": False, "error": f"No event found matching '{query}'."}
+    event_to_update = matches[0]
+    fields: dict = {}
+    for str_field in ("title", "description", "location", "color", "recurrence"):
+        if arguments.get(str_field) is not None:
+            fields[str_field] = arguments[str_field]
+    if arguments.get("all_day") is not None:
+        fields["all_day"] = arguments["all_day"]
+    if "reminder_minutes" in arguments:
+        rm = arguments["reminder_minutes"]
+        fields["reminder_minutes"] = None if rm == 0 else rm
+    for dt_field, key in (("start_dt", "start"), ("end_dt", "end")):
+        val = arguments.get(key)
+        if val:
+            try:
+                # Naive datetimes are user-local, not UTC — see
+                # ``_parse_datetime_in_user_tz`` docstring.
+                dt, _ = await _parse_datetime_in_user_tz(user_id, val)
+                fields[dt_field] = dt
+            except (ValueError, TypeError):
+                return {"success": False, "error": f"Invalid datetime for {key}: {val!r}"}
+    updated = await events_update_event(user_id=user_id, event_id=event_to_update.id, **fields)
+    if updated is None:
+        return {"success": False, "error": "Event not found or update failed."}
+    return {"success": True, "type": "event_updated", "data": updated.to_dict()}
+
+
+@tool(
+    name="delete_event",
+    description="Delete a calendar event. Use this when the user asks to cancel, remove, or delete an event.",
+    parameters={
+        "query": {"type": "string", "description": "Search term to find the event to delete (matches against title)"},
+    },
+    required=["query"],
+)
+async def delete_event_tool(*, user_id, arguments, **_ctx):
+    query = arguments.get("query", "")
+    matches = await find_events_by_query(user_id=user_id, query=query)
+    if not matches:
+        return {"success": False, "error": f"No event found matching '{query}'."}
+    event_to_delete = matches[0]
+    await events_delete_event(user_id=user_id, event_id=event_to_delete.id)
+    return {"success": True, "type": "event_deleted", "data": {"id": event_to_delete.id, "title": event_to_delete.title}}
+
+
+@tool(
+    name="list_calendars",
+    description="List all available calendars. Use this when the user asks which calendars they have.",
+    parameters={},
+    read_only=True,
+    requires="caldav",
+)
+async def list_calendars_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.caldav import list_calendars
+
+    calendars = await list_calendars(user_id=user_id)
+    return {
+        "success": True,
+        "type": "calendars",
+        "data": {"count": len(calendars), "calendars": calendars},
+    }

src/fabledassistant/services/tools/entities.py

@@ -0,0 +1,231 @@
+"""Entity tools: people, places, and lists."""
+
+from __future__ import annotations
+
+from fabledassistant.services.notes import create_note, list_notes, update_note
+from fabledassistant.services.tools._helpers import schedule_embedding
+from fabledassistant.services.tools._registry import tool
+
+
+def _build_person_body(meta: dict, extra_notes: str | None = None) -> str:
+    """Build markdown body from person metadata."""
+    lines = []
+    for key, label in (("relationship", "Relationship"), ("phone", "Phone"), ("email", "Email"), ("birthday", "Birthday"), ("address", "Address")):
+        if meta.get(key):
+            lines.append(f"**{label}:** {meta[key]}")
+    if extra_notes:
+        lines.append(f"\n{extra_notes}")
+    return "\n".join(lines)
+
+
+def _build_place_body(meta: dict, extra_notes: str | None = None) -> str:
+    """Build markdown body from place metadata."""
+    lines = []
+    for key, label in (("address", "Address"), ("phone", "Phone"), ("hours", "Hours"), ("url", "Website")):
+        if meta.get(key):
+            lines.append(f"**{label}:** {meta[key]}")
+    if extra_notes:
+        lines.append(f"\n{extra_notes}")
+    return "\n".join(lines)
+
+
+_PERSON_FIELDS = ("relationship", "phone", "email", "birthday", "address")
+_PLACE_FIELDS = ("address", "phone", "hours", "url")
+
+
+@tool(
+    name="save_person",
+    description=(
+        "Save or update a person in the user's knowledge base. Creates a new entry if the "
+        "person doesn't exist, or updates an existing one. Use when the user introduces "
+        "someone by name or adds/corrects details about a known person."
+    ),
+    parameters={
+        "name": {"type": "string", "description": "Full name of the person (used to find existing entry or as new entry title)"},
+        "relationship": {"type": "string", "description": "Relationship to the user (e.g. daughter, dentist, colleague)"},
+        "phone": {"type": "string", "description": "Phone number"},
+        "email": {"type": "string", "description": "Email address"},
+        "birthday": {"type": "string", "description": "Birthday in YYYY-MM-DD format"},
+        "address": {"type": "string", "description": "Home or mailing address"},
+        "notes": {"type": "string", "description": "Any additional free-form notes about this person"},
+    },
+    required=["name"],
+)
+async def save_person_tool(*, user_id, arguments, **_ctx):
+    name = str(arguments.get("name", "")).strip()
+    if not name:
+        return {"success": False, "error": "name is required"}
+
+    existing, _ = await list_notes(user_id=user_id, q=name, is_task=False, limit=10)
+    target = next((n for n in existing if n.note_type == "person"), None)
+
+    if target is not None:
+        meta = dict(target.entity_meta or {})
+        for field in _PERSON_FIELDS:
+            val = arguments.get(field)
+            if val is not None:
+                meta[field] = str(val)
+        extra_notes = arguments.get("notes")
+        body = _build_person_body(meta, extra_notes)
+        updated = await update_note(user_id=user_id, note_id=target.id, body=body, entity_meta=meta)
+        if updated is None:
+            return {"success": False, "error": "Failed to update person."}
+        schedule_embedding(target.id, user_id, target.title, body)
+        return {"success": True, "type": "person_updated", "data": {"id": target.id, "name": target.title}}
+
+    meta = {}
+    for field in _PERSON_FIELDS:
+        val = arguments.get(field)
+        if val:
+            meta[field] = str(val)
+    body = _build_person_body(meta, arguments.get("notes", ""))
+    note = await create_note(
+        user_id=user_id, title=name, body=body,
+        tags=["person"], note_type="person", entity_meta=meta,
+    )
+    schedule_embedding(note.id, user_id, name, note.body)
+    return {"success": True, "type": "person", "data": {"id": note.id, "name": name}}
+
+
+@tool(
+    name="save_place",
+    description=(
+        "Save or update a named location in the user's knowledge base. Creates a new entry "
+        "if the place doesn't exist, or updates an existing one. Use when the user wants to "
+        "remember or correct details about a place (business, venue, address)."
+    ),
+    parameters={
+        "name": {"type": "string", "description": "Name of the place (e.g. 'Dr. Smith Dental', 'Costco')"},
+        "address": {"type": "string", "description": "Street address"},
+        "phone": {"type": "string", "description": "Phone number"},
+        "hours": {"type": "string", "description": "Opening hours (e.g. 'Mon-Fri 9am-5pm')"},
+        "url": {"type": "string", "description": "Website URL"},
+        "notes": {"type": "string", "description": "Any additional free-form notes about this place"},
+    },
+    required=["name"],
+)
+async def save_place_tool(*, user_id, arguments, **_ctx):
+    name = str(arguments.get("name", "")).strip()
+    if not name:
+        return {"success": False, "error": "name is required"}
+
+    existing, _ = await list_notes(user_id=user_id, q=name, is_task=False, limit=10)
+    target = next((n for n in existing if n.note_type == "place"), None)
+
+    if target is not None:
+        meta = dict(target.entity_meta or {})
+        for field in _PLACE_FIELDS:
+            val = arguments.get(field)
+            if val is not None:
+                meta[field] = str(val)
+        extra_notes = arguments.get("notes")
+        body = _build_place_body(meta, extra_notes)
+        updated = await update_note(user_id=user_id, note_id=target.id, body=body, entity_meta=meta)
+        if updated is None:
+            return {"success": False, "error": "Failed to update place."}
+        schedule_embedding(target.id, user_id, target.title, body)
+        return {"success": True, "type": "place_updated", "data": {"id": target.id, "name": target.title}}
+
+    meta = {}
+    for field in _PLACE_FIELDS:
+        val = arguments.get(field)
+        if val:
+            meta[field] = str(val)
+    body = _build_place_body(meta, arguments.get("notes", ""))
+    note = await create_note(
+        user_id=user_id, title=name, body=body,
+        tags=["place"], note_type="place", entity_meta=meta,
+    )
+    schedule_embedding(note.id, user_id, name, note.body)
+    return {"success": True, "type": "place", "data": {"id": note.id, "name": name}}
+
+
+@tool(
+    name="create_list",
+    description="Create a named list (shopping list, to-do list, packing list, etc.). Items are stored as a markdown task list. Use add_to_list to add items to an existing list.",
+    parameters={
+        "name": {"type": "string", "description": "List name (e.g. 'Grocery List', 'Hardware Store')"},
+        "items": {"type": "array", "items": {"type": "string"}, "description": "Initial list items (unchecked)"},
+        "store": {"type": "string", "description": "Optional associated store or place name"},
+        "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags for the list"},
+    },
+    required=["name"],
+)
+async def create_list_tool(*, user_id, arguments, **_ctx):
+    name = str(arguments.get("name", "")).strip()
+    if not name:
+        return {"success": False, "error": "name is required"}
+    items = arguments.get("items") or []
+    if not isinstance(items, list):
+        items = []
+    body = "\n".join(f"- [ ] {item}" for item in items if str(item).strip())
+    meta = {}
+    store = arguments.get("store")
+    if store:
+        meta["store"] = str(store)
+    tags = arguments.get("tags") or []
+    if not isinstance(tags, list):
+        tags = []
+    note = await create_note(
+        user_id=user_id, title=name, body=body,
+        tags=tags, note_type="list", entity_meta=meta,
+    )
+    schedule_embedding(note.id, user_id, name, body)
+    return {"success": True, "type": "list", "data": {"id": note.id, "name": name, "item_count": len(items)}}
+
+
+@tool(
+    name="add_to_list",
+    description="Add one or more items to an existing list. Items are appended as unchecked entries.",
+    parameters={
+        "list_name": {"type": "string", "description": "Name of the list to add items to"},
+        "items": {"type": "array", "items": {"type": "string"}, "description": "Items to add"},
+    },
+    required=["list_name", "items"],
+)
+async def add_to_list_tool(*, user_id, arguments, **_ctx):
+    list_name = str(arguments.get("list_name", "")).strip()
+    items = arguments.get("items") or []
+    if not list_name:
+        return {"success": False, "error": "list_name is required"}
+    if not isinstance(items, list) or not items:
+        return {"success": False, "error": "items must be a non-empty array"}
+    existing, _ = await list_notes(user_id=user_id, q=list_name, is_task=False, limit=10)
+    target = next((n for n in existing if n.note_type == "list" and n.title.lower() == list_name.lower()), None)
+    if target is None:
+        target = next((n for n in existing if n.note_type == "list"), None)
+    if target is None:
+        return {"success": False, "error": f"No list named '{list_name}' found. Use create_list to create it first."}
+    new_lines = "\n".join(f"- [ ] {item}" for item in items if str(item).strip())
+    existing_body = (target.body or "").rstrip()
+    new_body = f"{existing_body}\n{new_lines}".lstrip()
+    await update_note(user_id=user_id, note_id=target.id, body=new_body)
+    schedule_embedding(target.id, user_id, target.title, new_body)
+    return {"success": True, "type": "list_updated", "data": {"id": target.id, "name": target.title, "added": len(items)}}
+
+
+@tool(
+    name="clear_checked_items",
+    description="Remove all checked/completed items from a list, keeping only unchecked items.",
+    parameters={
+        "list_name": {"type": "string", "description": "Name of the list to clear"},
+    },
+    required=["list_name"],
+)
+async def clear_checked_items_tool(*, user_id, arguments, **_ctx):
+    import re as _re
+
+    list_name = str(arguments.get("list_name", "")).strip()
+    if not list_name:
+        return {"success": False, "error": "list_name is required"}
+    existing, _ = await list_notes(user_id=user_id, q=list_name, is_task=False, limit=10)
+    target = next((n for n in existing if n.note_type == "list" and n.title.lower() == list_name.lower()), None)
+    if target is None:
+        target = next((n for n in existing if n.note_type == "list"), None)
+    if target is None:
+        return {"success": False, "error": f"No list named '{list_name}' found."}
+    body = target.body or ""
+    cleaned = _re.sub(r"^- \[[xX]\] .+\n?", "", body, flags=_re.MULTILINE).strip()
+    await update_note(user_id=user_id, note_id=target.id, body=cleaned)
+    schedule_embedding(target.id, user_id, target.title, cleaned)
+    return {"success": True, "type": "list_cleared", "data": {"id": target.id, "name": target.title}}

src/fabledassistant/services/tools/notes.py

@@ -0,0 +1,420 @@
+"""Note tools: create, update, get, list, delete, search."""
+
+from __future__ import annotations
+
+import logging
+
+from fabledassistant.services.notes import create_note, delete_note, get_note_by_title, list_notes, update_note
+from fabledassistant.services.tag_suggestions import suggest_tags
+from fabledassistant.services.tools._helpers import (
+    check_duplicate,
+    parse_due_date,
+    resolve_project,
+    schedule_embedding,
+)
+from fabledassistant.services.tools._registry import tool
+
+logger = logging.getLogger(__name__)
+
+
+@tool(
+    name="create_note",
+    description=(
+        "Create a new note or task. "
+        "For a knowledge note, omit the status field. "
+        "For an actionable task (todo, reminder, action item), set status to 'todo'. "
+        "Use this whenever the user asks to write down, save, record, or add a task/todo."
+    ),
+    parameters={
+        "title": {"type": "string", "description": "The title"},
+        "body": {"type": "string", "description": "Content in markdown"},
+        "tags": {"type": "array", "items": {"type": "string"}, "description": 'Tags (without # prefix, hyphens for multi-word: ["science-fiction", "story/idea"]). Do NOT embed #tags in the body.'},
+        "project": {"type": "string", "description": "Optional project name. Only set this if the user explicitly named a project. Do NOT infer a project from the content or context."},
+        "status": {"type": "string", "enum": ["todo", "in_progress", "done", "cancelled"], "description": "Set to 'todo' to create a task. Omit entirely for a knowledge note."},
+        "due_date": {"type": "string", "description": "Due date in YYYY-MM-DD format (tasks only)"},
+        "priority": {"type": "string", "enum": ["none", "low", "medium", "high"], "description": "Priority level (tasks only, default: none)"},
+        "parent_task": {"type": "string", "description": "Title of a parent task to make this a sub-task of"},
+        "milestone": {"type": "string", "description": "Milestone title within the project to assign to"},
+        "recurrence_rule": {"type": "object", "description": 'Recurrence rule (tasks only). Interval form: {"type":"interval","every":3,"unit":"month"} (units: day/week/month/year). Calendar form: {"type":"calendar","unit":"month","day_of_month":1}. Annual: add "month":6.'},
+        "confirmed": {"type": "boolean", "description": "Set to true only when the user has explicitly confirmed creation after being warned about a similar existing item."},
+    },
+    required=["title"],
+)
+async def create_note_tool(*, user_id, arguments, **_ctx):
+    title = arguments.get("title", "Untitled")
+    body = arguments.get("body", "")
+    tags = arguments.get("tags", [])
+    if not isinstance(title, str):
+        return {"success": False, "error": "title must be a string. Call create_note once per item."}
+    if not isinstance(body, str):
+        body = ""
+    if not isinstance(tags, list):
+        tags = []
+
+    is_task = "status" in arguments and arguments["status"] is not None
+    status = arguments.get("status", "todo") if is_task else None
+
+    project_name = arguments.get("project")
+    milestone_name = arguments.get("milestone")
+    parent_task_name = arguments.get("parent_task")
+    project_id = None
+    milestone_id = None
+
+    if project_name:
+        proj = await resolve_project(user_id, project_name)
+        if proj is None:
+            return {"success": False, "error": f"Project '{project_name}' not found. Use list_projects to find the correct project name and retry with the exact name."}
+        project_id = proj.id
+        if milestone_name:
+            from fabledassistant.services.milestones import get_milestone_by_title as _gmbt
+            ms = await _gmbt(user_id, proj.id, milestone_name)
+            if ms is None:
+                return {"success": False, "error": f"Milestone '{milestone_name}' not found in project '{proj.title}'. Use list_milestones to see available milestones."}
+            milestone_id = ms.id
+
+    dup = await check_duplicate(user_id, title, body, is_task=is_task, confirmed=bool(arguments.get("confirmed")))
+    if dup is not None:
+        return dup
+
+    note = await create_note(
+        user_id=user_id,
+        title=title,
+        body=body,
+        tags=tags,
+        status=status,
+        priority=arguments.get("priority", "none") if is_task else None,
+        due_date=parse_due_date(arguments.get("due_date")) if is_task else None,
+        recurrence_rule=arguments.get("recurrence_rule") if is_task else None,
+        project_id=project_id,
+        milestone_id=milestone_id,
+    )
+
+    if parent_task_name:
+        parent_notes, _ = await list_notes(user_id=user_id, q=parent_task_name, is_task=True, limit=1)
+        if parent_notes:
+            note = await update_note(user_id, note.id, parent_id=parent_notes[0].id)
+
+    suggested = await suggest_tags(user_id, title, body)
+    schedule_embedding(note.id, user_id, title, body)
+
+    if is_task:
+        return {
+            "success": True,
+            "type": "task",
+            "data": {
+                "id": note.id,
+                "title": note.title,
+                "status": note.status,
+                "priority": note.priority,
+                "due_date": str(note.due_date) if note.due_date else None,
+                "project_id": note.project_id,
+                "milestone_id": note.milestone_id,
+                "parent_id": note.parent_id,
+            },
+            "suggested_tags": suggested,
+        }
+    return {
+        "success": True,
+        "type": "note",
+        "data": {"id": note.id, "title": note.title, "project_id": note.project_id},
+        "suggested_tags": suggested,
+    }
+
+
+@tool(
+    name="update_note",
+    description="Update an existing note or task — content, title, status, priority, or due date. Use for edits, marking tasks done, changing priority. Never use create_note for existing notes.",
+    parameters={
+        "query": {"type": "string", "description": "Title or keyword to find the note or task to update"},
+        "body": {"type": "string", "description": "New note content in markdown (omit if only updating task fields)"},
+        "title": {"type": "string", "description": "Optional new title"},
+        "mode": {"type": "string", "enum": ["replace", "append"], "description": "How to apply the new body: 'replace' overwrites existing content (default), 'append' adds after existing content"},
+        "status": {"type": "string", "enum": ["todo", "in_progress", "done", "cancelled"], "description": "New task status. Use to mark a task done, start it, cancel it, etc."},
+        "priority": {"type": "string", "enum": ["none", "low", "medium", "high"], "description": "New task priority"},
+        "due_date": {"type": "string", "description": "New due date in YYYY-MM-DD format"},
+        "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags to apply (see tag_mode for how they're applied)"},
+        "tag_mode": {"type": "string", "enum": ["add", "remove", "replace"], "description": "'add' appends tags without duplicates (default), 'remove' removes listed tags, 'replace' sets tags to exactly this list (destructive — avoid unless explicitly requested)"},
+        "project": {"type": "string", "description": "Optional project name to assign this note/task to (set to empty string to remove project)"},
+        "milestone": {"type": "string", "description": "Optional milestone title within the project to assign this task to (set to empty string to remove milestone)"},
+        "recurrence_rule": {"type": "object", "description": 'Set or update recurrence. Interval form: {"type":"interval","every":3,"unit":"month"}. Calendar form: {"type":"calendar","unit":"month","day_of_month":1}. Pass null to remove.'},
+    },
+    required=["query"],
+)
+async def update_note_tool(*, user_id, arguments, **_ctx):
+    query = arguments.get("query", "")
+    new_body = arguments.get("body", "")
+    new_title = arguments.get("title")
+    mode = arguments.get("mode", "replace")
+
+    note = await get_note_by_title(user_id, query)
+    if note is None:
+        notes, _ = await list_notes(user_id=user_id, q=query, limit=5)
+        note_only = [n for n in notes if n.status is None]
+        candidates = note_only or notes
+        if not candidates:
+            return {"success": False, "error": f"No note found matching '{query}'."}
+        note = candidates[0]
+
+    update_fields: dict = {}
+    if new_title:
+        update_fields["title"] = new_title
+    if new_body:
+        if mode == "append" and note.body:
+            update_fields["body"] = note.body + "\n\n" + new_body
+        else:
+            update_fields["body"] = new_body
+    if "status" in arguments:
+        update_fields["status"] = arguments["status"]
+    if "priority" in arguments:
+        update_fields["priority"] = arguments["priority"]
+    if "due_date" in arguments:
+        update_fields["due_date"] = parse_due_date(arguments["due_date"])
+    if "tags" in arguments:
+        new_tags = arguments["tags"]
+        if isinstance(new_tags, list):
+            tag_mode = arguments.get("tag_mode", "add")
+            if tag_mode == "add":
+                existing = list(note.tags or [])
+                for t in new_tags:
+                    if t not in existing:
+                        existing.append(t)
+                update_fields["tags"] = existing
+            elif tag_mode == "remove":
+                existing = list(note.tags or [])
+                update_fields["tags"] = [t for t in existing if t not in new_tags]
+            else:
+                update_fields["tags"] = new_tags
+
+    if "project" in arguments:
+        project_name = arguments["project"]
+        if project_name:
+            proj = await resolve_project(user_id, project_name)
+            if proj is None:
+                return {"success": False, "error": f"Project '{project_name}' not found. Use list_projects to see available projects."}
+            update_fields["project_id"] = proj.id
+        else:
+            update_fields["project_id"] = None
+            update_fields["milestone_id"] = None
+
+    if "milestone" in arguments:
+        milestone_name = arguments["milestone"]
+        if milestone_name:
+            ref_project_id = update_fields.get("project_id") or note.project_id
+            if ref_project_id is None:
+                return {"success": False, "error": "Cannot assign a milestone without a project. Set project first."}
+            from fabledassistant.services.milestones import get_milestone_by_title as _gmbt_upd
+            ms = await _gmbt_upd(user_id, ref_project_id, milestone_name)
+            if ms is None:
+                return {"success": False, "error": f"Milestone '{milestone_name}' not found. Use list_milestones to see available milestones."}
+            update_fields["milestone_id"] = ms.id
+        else:
+            update_fields["milestone_id"] = None
+
+    updated = await update_note(user_id, note.id, **update_fields)
+    if updated is None:
+        return {"success": False, "error": "Failed to update note."}
+
+    suggested = await suggest_tags(user_id, updated.title, updated.body or "")
+    schedule_embedding(updated.id, user_id, updated.title, updated.body or "")
+    item_type = "task" if updated.status is not None else "note"
+    return {
+        "success": True,
+        "type": "note_updated",
+        "updated": f"{item_type} '{updated.title}' (id: {updated.id})",
+        "data": {
+            "id": updated.id,
+            "title": updated.title,
+            "item_type": item_type,
+            "status": updated.status,
+            "tags": updated.tags or [],
+            "project_id": updated.project_id,
+        },
+        "suggested_tags": suggested,
+    }
+
+
+@tool(
+    name="search_notes",
+    description="Find notes or tasks by meaning. Returns a ranked list of matches with short previews. Use this when looking for items on a topic but you don't know the exact title. For the full body of a known item, use read_note instead.",
+    parameters={
+        "query": {"type": "string", "description": "A natural-language description of what you're looking for — concepts, themes, topics, or keywords"},
+        "type": {"type": "string", "enum": ["note", "task"], "description": "Restrict results to only notes or only tasks. Omit to search both."},
+        "project": {"type": "string", "description": "Optional project name to restrict search to notes in that project"},
+    },
+    required=["query"],
+    read_only=True,
+    briefing=True,
+)
+async def search_notes_tool(*, user_id, arguments, **_ctx):
+    query = arguments.get("query", "")
+    type_filter = arguments.get("type")
+    project_name = arguments.get("project")
+
+    is_task: bool | None = None
+    if type_filter == "note":
+        is_task = False
+    elif type_filter == "task":
+        is_task = True
+
+    search_project_id: int | None = None
+    if project_name:
+        proj = await resolve_project(user_id, project_name)
+        if proj:
+            search_project_id = proj.id
+
+    results_map: dict[int, dict] = {}
+
+    try:
+        from fabledassistant.services.embeddings import semantic_search_notes as _ssn
+        sem_results = await _ssn(
+            user_id, query, limit=8, threshold=0.40,
+            project_id=search_project_id,
+        )
+        for score, n in sem_results:
+            n_is_task = n.status is not None
+            if is_task is True and not n_is_task:
+                continue
+            if is_task is False and n_is_task:
+                continue
+            results_map[n.id] = {
+                "id": n.id,
+                "title": n.title,
+                "type": "task" if n_is_task else "note",
+                "status": n.status,
+                "relevance": f"{round(score * 100)}%",
+                "preview": (n.body[:300] + "\u2026") if n.body and len(n.body) > 300 else (n.body or ""),
+            }
+        logger.debug("search_notes semantic: %d results for %r", len(results_map), query)
+    except Exception:
+        logger.debug("Semantic search unavailable in search_notes, using keyword only", exc_info=True)
+
+    try:
+        kw_notes, _ = await list_notes(
+            user_id=user_id, q=query, is_task=is_task,
+            project_id=search_project_id, limit=8,
+        )
+        for n in kw_notes:
+            if n.id not in results_map:
+                results_map[n.id] = {
+                    "id": n.id,
+                    "title": n.title,
+                    "type": "task" if n.status is not None else "note",
+                    "status": n.status,
+                    "relevance": "keyword",
+                    "preview": (n.body[:300] + "\u2026") if n.body and len(n.body) > 300 else (n.body or ""),
+                }
+    except Exception:
+        logger.warning("Keyword fallback in search_notes failed", exc_info=True)
+
+    results = list(results_map.values())[:8]
+    return {
+        "success": True,
+        "type": "search",
+        "data": {"query": query, "count": len(results), "results": results},
+    }
+
+
+@tool(
+    name="read_note",
+    description="Read the full content of one specific note or task. Use when you know which item you want and need its complete body text. For discovering items by topic, use search_notes instead.",
+    parameters={
+        "query": {"type": "string", "description": "Title or keyword to identify the note or task"},
+    },
+    required=["query"],
+    read_only=True,
+    briefing=True,
+)
+async def get_note_tool(*, user_id, arguments, **_ctx):
+    query = arguments.get("query", "")
+    note = await get_note_by_title(user_id, query)
+    if note is None:
+        notes, _ = await list_notes(user_id=user_id, q=query, limit=3)
+        if not notes:
+            return {"success": False, "error": f"No note found matching '{query}'."}
+        note = notes[0]
+    return {
+        "success": True,
+        "type": "note_content",
+        "data": {"id": note.id, "title": note.title, "body": note.body or "", "tags": note.tags or []},
+    }
+
+
+@tool(
+    name="list_notes",
+    description="Browse recent notes (not tasks) with optional filters. Returns titles and short previews. Use when the user asks 'show my notes' or wants to browse by tag, project, or recency. For tasks use list_tasks; for topic search use search_notes.",
+    parameters={
+        "q": {"type": "string", "description": "Optional keyword filter"},
+        "tags": {"type": "array", "items": {"type": "string"}, "description": "Filter notes that have ALL of these tags"},
+        "project": {"type": "string", "description": "Filter notes by project name"},
+        "sort": {"type": "string", "enum": ["updated_at", "created_at", "title"], "description": "Sort field (default: updated_at)"},
+        "limit": {"type": "integer", "description": "Maximum number of notes to return (default 10)"},
+    },
+    read_only=True,
+    briefing=True,
+)
+async def list_notes_tool(*, user_id, arguments, **_ctx):
+    tags_raw = arguments.get("tags")
+    tags = tags_raw if isinstance(tags_raw, list) else None
+    project_id = None
+    project_name = arguments.get("project")
+    if project_name:
+        proj = await resolve_project(user_id, project_name)
+        if proj is None:
+            return {"success": False, "error": f"Project '{project_name}' not found."}
+        project_id = proj.id
+    notes, total = await list_notes(
+        user_id=user_id,
+        q=arguments.get("q") or arguments.get("query"),
+        tags=tags,
+        is_task=False,
+        project_id=project_id,
+        sort=arguments.get("sort", "updated_at"),
+        order="desc",
+        limit=int(arguments.get("limit", 10)),
+    )
+    results = [
+        {
+            "id": n.id,
+            "title": n.title,
+            "tags": n.tags or [],
+            "updated_at": n.updated_at.isoformat(),
+            "preview": (n.body[:200] + "...") if n.body and len(n.body) > 200 else (n.body or ""),
+        }
+        for n in notes
+    ]
+    return {
+        "success": True,
+        "type": "notes_list",
+        "data": {"total": total, "count": len(results), "results": results},
+    }
+
+
+@tool(
+    name="delete_note",
+    description="Delete any item from the user's knowledge base permanently — notes, tasks, persons (created via save_person), places (created via save_place), and lists (created via create_list) are all stored as notes and use this single delete tool. Use ONLY when the user explicitly asks to delete or remove an item. Always confirm with the user first — this cannot be undone.",
+    parameters={
+        "query": {"type": "string", "description": "Title or keyword to find the item to delete (works for notes, tasks, persons, places, and lists)"},
+        "confirmed": {"type": "boolean", "description": "Must be true — only set after the user has explicitly confirmed they want this item deleted."},
+    },
+    required=["query"],
+)
+async def delete_note_tool(*, user_id, arguments, **_ctx):
+    query = arguments.get("query", "")
+    note = await get_note_by_title(user_id, query)
+    if note is None:
+        notes, _ = await list_notes(user_id=user_id, q=query, limit=3)
+        if not notes:
+            return {"success": False, "error": f"No note or task found matching '{query}'."}
+        note = notes[0]
+    if not arguments.get("confirmed"):
+        item_type = "task" if note.status is not None else "note"
+        return {
+            "success": False,
+            "requires_confirmation": True,
+            "error": f"Deleting {item_type} '{note.title}' is permanent. Ask the user to confirm, then retry with confirmed=true.",
+        }
+    deleted = await delete_note(user_id, note.id)
+    if not deleted:
+        return {"success": False, "error": "Failed to delete."}
+    item_type = "task" if note.status is not None else "note"
+    return {"success": True, "type": f"{item_type}_deleted", "data": {"id": note.id, "title": note.title}}

src/fabledassistant/services/tools/profile.py

@@ -0,0 +1,77 @@
+"""User profile tools."""
+
+from __future__ import annotations
+
+from fabledassistant.services.tools._registry import tool
+
+
+@tool(
+    name="get_profile",
+    description=(
+        "Retrieve the user's stored profile: name, job title, industry, expertise level, "
+        "preferred response style, tone, and interests. Use this when you need to personalise "
+        "a response and the user's profile hasn't already been injected into context."
+    ),
+    parameters={},
+    read_only=True,
+)
+async def get_profile_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.user_profile import get_profile as _get_profile
+
+    profile = await _get_profile(user_id)
+    return {
+        "success": True,
+        "type": "profile",
+        "data": {
+            "display_name": profile.display_name or "",
+            "job_title": profile.job_title or "",
+            "industry": profile.industry or "",
+            "expertise_level": profile.expertise_level or "intermediate",
+            "response_style": profile.response_style or "balanced",
+            "tone": profile.tone or "casual",
+            "interests": profile.interests or [],
+        },
+    }
+
+
+@tool(
+    name="update_profile",
+    description=(
+        "Update the user's stored profile when they share personal information: their name, "
+        "job, industry, expertise, preferred response style, tone, or interests. "
+        "Only set fields the user has explicitly mentioned."
+    ),
+    parameters={
+        "display_name": {"type": "string", "description": "User's preferred display name"},
+        "job_title": {"type": "string", "description": "Job title (e.g. 'Software Engineer')"},
+        "industry": {"type": "string", "description": "Industry (e.g. 'Healthcare', 'Finance')"},
+        "expertise_level": {"type": "string", "enum": ["novice", "intermediate", "expert"], "description": "User's general expertise level"},
+        "response_style": {"type": "string", "enum": ["concise", "balanced", "detailed"], "description": "Preferred response length/depth"},
+        "tone": {"type": "string", "enum": ["casual", "professional", "technical"], "description": "Preferred communication tone"},
+        "interests": {"type": "array", "items": {"type": "string"}, "description": "List of topics or hobbies the user is interested in"},
+    },
+)
+async def update_profile_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.user_profile import VALID_EXPERTISE, VALID_STYLES, VALID_TONES, update_profile as _update_profile
+
+    data: dict = {}
+    for field in ("display_name", "job_title", "industry"):
+        val = arguments.get(field)
+        if val is not None:
+            data[field] = str(val)
+    expertise = arguments.get("expertise_level")
+    if expertise in VALID_EXPERTISE:
+        data["expertise_level"] = expertise
+    style = arguments.get("response_style")
+    if style in VALID_STYLES:
+        data["response_style"] = style
+    tone = arguments.get("tone")
+    if tone in VALID_TONES:
+        data["tone"] = tone
+    interests = arguments.get("interests")
+    if isinstance(interests, list):
+        data["interests"] = [str(i) for i in interests if str(i).strip()]
+    if not data:
+        return {"success": False, "error": "No valid fields provided to update."}
+    await _update_profile(user_id, data)
+    return {"success": True, "type": "profile_updated", "data": {"fields_updated": list(data.keys())}}

src/fabledassistant/services/tools/projects.py

@@ -0,0 +1,258 @@
+"""Project and milestone tools."""
+
+from __future__ import annotations
+
+from fabledassistant.services.tools._helpers import fuzzy_title_match, resolve_project
+from fabledassistant.services.tools._registry import tool
+
+
+@tool(
+    name="create_project",
+    description="Create a new project. Use list_projects first to check for duplicates. Only call after user has explicitly confirmed.",
+    parameters={
+        "title": {"type": "string", "description": "Project title"},
+        "description": {"type": "string", "description": "Brief description"},
+        "goal": {"type": "string", "description": "The goal or desired outcome"},
+        "color": {"type": "string", "description": "Optional hex color for the project (e.g. '#6366f1')"},
+        "confirmed": {"type": "boolean", "description": "Must be true — only set after the user has explicitly confirmed they want this project created."},
+    },
+    required=["title", "confirmed"],
+)
+async def create_project_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.projects import create_project as _create_project, get_project_by_title as _gpbt, list_projects as _lp
+
+    proj_title = arguments.get("title", "New Project")
+    existing_proj = await _gpbt(user_id, proj_title)
+    if existing_proj is not None:
+        return {"success": False, "error": f"A project titled '{existing_proj.title}' already exists (id: {existing_proj.id}). Use that project instead of creating a duplicate."}
+    all_projects = await _lp(user_id)
+    near_proj, ratio = fuzzy_title_match(proj_title, all_projects, threshold=0.55)
+    if near_proj is not None:
+        return {"success": False, "requires_confirmation": True, "error": f"A project with a similar name '{near_proj.title}' already exists (id: {near_proj.id}, similarity: {ratio:.0%}). This is likely the project you meant — use that project's name instead. Only call create_project again if you are certain this should be a completely new, separate project with a different confirmed=true."}
+    if not arguments.get("confirmed"):
+        return {"success": False, "requires_confirmation": True, "error": f"Project creation requires explicit user confirmation. Ask the user: 'Shall I create a new project titled \"{proj_title}\"?' Then retry with confirmed=true if they agree."}
+    project = await _create_project(
+        user_id,
+        title=proj_title,
+        description=arguments.get("description", ""),
+        goal=arguments.get("goal", ""),
+        color=arguments.get("color") or None,
+    )
+    return {"success": True, "type": "project", "data": project.to_dict()}
+
+
+@tool(
+    name="list_projects",
+    description="List the user's projects. Use when asked about projects, initiatives, or campaigns.",
+    parameters={
+        "status": {"type": "string", "enum": ["active", "completed", "archived"], "description": "Filter by status (omit for all)"},
+    },
+    read_only=True,
+    briefing=True,
+)
+async def list_projects_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.projects import list_projects as _list_projects
+
+    projects = await _list_projects(user_id, status=arguments.get("status"))
+    return {
+        "success": True,
+        "type": "projects_list",
+        "data": {"count": len(projects), "projects": [p.to_dict() for p in projects]},
+    }
+
+
+@tool(
+    name="get_project",
+    description="Get details and summary of a specific project.",
+    parameters={
+        "query": {"type": "string", "description": "Project name or keyword to find it"},
+    },
+    required=["query"],
+    read_only=True,
+    briefing=True,
+)
+async def get_project_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.projects import get_project_by_title as _gpbt, get_project_summary as _gps, list_projects as _lp
+
+    query = arguments.get("query", "")
+    project = await _gpbt(user_id, query)
+    if project is None:
+        all_projects = await _lp(user_id)
+        matches = [p for p in all_projects if query.lower() in p.title.lower()]
+        if matches:
+            project = matches[0]
+    if project is None:
+        return {"success": False, "error": f"No project found matching '{query}'"}
+    summary = await _gps(user_id, project.id)
+    data = project.to_dict()
+    data["summary"] = summary
+    return {"success": True, "type": "project_detail", "data": data}
+
+
+@tool(
+    name="update_project",
+    description="Update a project's title, status, description, goal, or color.",
+    parameters={
+        "query": {"type": "string", "description": "Project name to find"},
+        "title": {"type": "string", "description": "New project title"},
+        "status": {"type": "string", "enum": ["active", "completed", "archived"]},
+        "description": {"type": "string"},
+        "goal": {"type": "string"},
+        "color": {"type": "string", "description": "Hex color (e.g. '#6366f1'), or empty string to clear"},
+    },
+    required=["query"],
+)
+async def update_project_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.projects import get_project_by_title as _gpbt, update_project as _up, list_projects as _lp
+
+    query = arguments.get("query", "")
+    project = await _gpbt(user_id, query)
+    if project is None:
+        all_projects = await _lp(user_id)
+        matches = [p for p in all_projects if query.lower() in p.title.lower()]
+        if matches:
+            project = matches[0]
+    if project is None:
+        return {"success": False, "error": f"No project found matching '{query}'"}
+    fields = {}
+    for k in ("title", "status", "description", "goal"):
+        if k in arguments:
+            fields[k] = arguments[k]
+    if "color" in arguments:
+        fields["color"] = arguments["color"] or None
+    updated = await _up(user_id, project.id, **fields)
+    return {"success": True, "type": "project_updated", "data": updated.to_dict()}
+
+
+@tool(
+    name="search_projects",
+    description="Search for projects by name, description, or theme. Use this to find which project a user is referring to and get its ID for set_rag_scope.",
+    parameters={
+        "query": {"type": "string", "description": "Search query — project name, topic, or theme"},
+    },
+    required=["query"],
+    read_only=True,
+    briefing=True,
+)
+async def search_projects_tool(*, user_id, arguments, **_ctx):
+    from difflib import SequenceMatcher
+
+    from fabledassistant.services.projects import list_projects
+
+    query = str(arguments.get("query", "")).lower()
+    projects = await list_projects(user_id)
+    scored: list[tuple[float, object]] = []
+    for p in projects:
+        combined = f"{p.title} {p.description or ''} {p.auto_summary or ''}".lower()
+        base_score = SequenceMatcher(None, query, combined).ratio()
+        query_words = set(query.split())
+        overlap = sum(1 for w in query_words if w in combined)
+        score = base_score + overlap * 0.05
+        scored.append((score, p))
+    scored.sort(key=lambda x: x[0], reverse=True)
+    results = []
+    for score, p in scored[:5]:
+        results.append({
+            "id": p.id,
+            "title": p.title,
+            "summary_snippet": (p.auto_summary or p.description or "")[:200],
+            "score": round(score, 3),
+        })
+    return {"type": "projects_list", "data": {"projects": results}}
+
+
+@tool(
+    name="create_milestone",
+    description="Create a milestone inside a project. Confirm name and project with user before calling.",
+    parameters={
+        "project": {"type": "string", "description": "Project title"},
+        "title": {"type": "string", "description": "Milestone title"},
+        "description": {"type": "string", "description": "Optional description"},
+        "confirmed": {"type": "boolean", "description": "Must be true — only set after the user has explicitly confirmed they want this milestone created."},
+    },
+    required=["project", "title", "confirmed"],
+)
+async def create_milestone_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.milestones import create_milestone as _cm, get_milestone_by_title as _gmbt2, list_milestones as _lms
+
+    project_name = arguments.get("project", "")
+    ms_title = arguments.get("title", "Untitled Milestone")
+    if not project_name:
+        return {"success": False, "error": "project is required"}
+    if not arguments.get("confirmed"):
+        return {"success": False, "requires_confirmation": True, "error": f"Milestone creation requires explicit user confirmation. Ask the user: 'Shall I create a milestone titled \"{ms_title}\" in project \"{project_name}\"?' Then retry with confirmed=true if they agree."}
+    proj = await resolve_project(user_id, project_name)
+    if proj is None:
+        return {"success": False, "error": f"Project '{project_name}' not found. Use list_projects to find the correct project name and retry with the exact name."}
+    existing_ms = await _gmbt2(user_id, proj.id, ms_title)
+    if existing_ms is not None:
+        return {"success": False, "error": f"A milestone titled '{existing_ms.title}' already exists in '{proj.title}' (id: {existing_ms.id}). Use update_milestone to modify it instead."}
+    all_ms = await _lms(user_id, proj.id)
+    near_ms, ratio = fuzzy_title_match(ms_title, all_ms)
+    if near_ms is not None:
+        return {"success": False, "error": f"A milestone with a very similar title '{near_ms.title}' already exists in '{proj.title}' (id: {near_ms.id}, similarity: {ratio:.0%}). Use update_milestone to modify it instead."}
+    ms = await _cm(user_id, proj.id, title=ms_title, description=arguments.get("description"))
+    return {"success": True, "type": "milestone", "data": ms.to_dict()}
+
+
+@tool(
+    name="update_milestone",
+    description="Update the title, description, or status of an existing milestone.",
+    parameters={
+        "project": {"type": "string", "description": "Project title the milestone belongs to"},
+        "milestone": {"type": "string", "description": "Current milestone title to look up"},
+        "title": {"type": "string", "description": "New title (omit to keep current)"},
+        "description": {"type": "string", "description": "New description (omit to keep current)"},
+        "status": {"type": "string", "enum": ["active", "done"], "description": "New status: 'active' (in progress) or 'done' (completed)"},
+    },
+    required=["project", "milestone"],
+)
+async def update_milestone_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.milestones import get_milestone_by_title as _gmbt, update_milestone as _um
+
+    project_name = arguments.get("project", "")
+    milestone_name = arguments.get("milestone", "")
+    if not project_name or not milestone_name:
+        return {"success": False, "error": "Both project and milestone are required"}
+    proj = await resolve_project(user_id, project_name)
+    if proj is None:
+        return {"success": False, "error": f"Project '{project_name}' not found"}
+    ms = await _gmbt(user_id, proj.id, milestone_name)
+    if ms is None:
+        return {"success": False, "error": f"Milestone '{milestone_name}' not found in project '{proj.title}'. Use list_milestones to see available milestones."}
+    fields: dict[str, object] = {}
+    if "title" in arguments:
+        fields["title"] = arguments["title"]
+    if "description" in arguments:
+        fields["description"] = arguments["description"]
+    if "status" in arguments:
+        fields["status"] = arguments["status"]
+    if not fields:
+        return {"success": False, "error": "No fields to update — provide at least one of: title, description, status"}
+    updated = await _um(user_id, ms.id, **fields)
+    return {"success": True, "type": "milestone", "data": updated.to_dict()}
+
+
+@tool(
+    name="list_milestones",
+    description="List milestones for a project with their progress percentages.",
+    parameters={
+        "project": {"type": "string", "description": "Project name to look up"},
+    },
+    required=["project"],
+    read_only=True,
+    briefing=True,
+)
+async def list_milestones_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.milestones import get_project_milestone_summary
+
+    project_name = arguments.get("project", "")
+    proj = await resolve_project(user_id, project_name)
+    if proj is None:
+        return {"success": False, "error": f"No project found matching '{project_name}'"}
+    summary = await get_project_milestone_summary(user_id, proj.id)
+    return {
+        "success": True,
+        "type": "milestones_list",
+        "data": {"project": proj.title, "count": len(summary), "milestones": summary},
+    }

src/fabledassistant/services/tools/rag.py

@@ -0,0 +1,34 @@
+"""RAG scope tool."""
+
+from __future__ import annotations
+
+from fabledassistant.services.tools._registry import tool
+
+
+@tool(
+    name="set_rag_scope",
+    description="Change the RAG scope for this conversation. Use project_id=<int> to scope to a project, project_id=null to scope to orphan notes only, project_id=-1 for all notes.",
+    parameters={
+        "project_id": {"type": ["integer", "null"], "description": "Project ID to scope to, null for orphan-only, -1 for all notes"},
+    },
+    required=["project_id"],
+)
+async def set_rag_scope_tool(*, user_id, arguments, conv_id=None, workspace_project_id=None, **_ctx):
+    if workspace_project_id is not None:
+        return {"success": False, "error": "Cannot change RAG scope in workspace view"}
+    if conv_id is None:
+        return {"success": False, "error": "No conversation context available"}
+    project_id = arguments.get("project_id")
+    if project_id is not None and project_id != -1:
+        from fabledassistant.services.projects import get_project
+        proj = await get_project(user_id, int(project_id))
+        if proj is None:
+            return {"success": False, "error": "Project not found"}
+        scope_label = proj.title
+    elif project_id == -1:
+        scope_label = "All notes"
+    else:
+        scope_label = "Orphan notes only"
+    from fabledassistant.services.chat import update_conversation
+    await update_conversation(user_id, conv_id, rag_project_id=project_id)
+    return {"success": True, "type": "rag_scope_set", "scope_label": scope_label}

src/fabledassistant/services/tools/rss.py

@@ -0,0 +1,101 @@
+"""RSS and article tools."""
+
+from __future__ import annotations
+
+import logging
+
+from fabledassistant.services.tools._registry import tool
+
+logger = logging.getLogger(__name__)
+
+
+@tool(
+    name="get_rss_items",
+    description="Get recent items from the user's RSS feeds (news, blogs, Reddit, podcasts). Returns titles, URLs, and summaries of recent posts.",
+    parameters={
+        "limit": {"type": "integer", "description": "Number of items to return (default 15, max 50)"},
+        "category": {"type": "string", "description": "Filter by feed category (e.g. 'news', 'tech'). Omit for all."},
+    },
+    read_only=True,
+    briefing=True,
+    requires="rss",
+)
+async def get_rss_items_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.rss import get_recent_items
+
+    limit = min(int(arguments.get("limit", 15)), 50)
+    items = await get_recent_items(user_id, limit=limit)
+    return {"data": {"items": items, "count": len(items)}}
+
+
+@tool(
+    name="add_rss_feed",
+    description="Add an RSS/Atom feed. Use when user asks to subscribe to or track a feed, blog, subreddit, or podcast.",
+    parameters={
+        "url": {"type": "string", "description": "The RSS/Atom feed URL to add."},
+        "category": {"type": "string", "description": "Optional category label (e.g. 'news', 'tech', 'reddit'). Omit if unsure."},
+    },
+    required=["url"],
+    requires="rss",
+)
+async def add_rss_feed_tool(*, user_id, arguments, **_ctx):
+    import asyncio as _asyncio
+
+    from sqlalchemy import select as _select
+
+    from fabledassistant.models import async_session as _async_session
+    from fabledassistant.models.rss_feed import RssFeed
+    from fabledassistant.services.rss import fetch_and_cache_feed
+
+    url = str(arguments.get("url", "")).strip()
+    if not url:
+        return {"error": "url is required"}
+    category = arguments.get("category") or None
+    async with _async_session() as session:
+        existing = await session.execute(
+            _select(RssFeed).where(RssFeed.user_id == user_id, RssFeed.url == url)
+        )
+        if existing.scalars().first():
+            return {"error": "Feed already added", "url": url}
+        feed = RssFeed(user_id=user_id, url=url, title="", category=category)
+        session.add(feed)
+        await session.commit()
+        await session.refresh(feed)
+        feed_id = feed.id
+    _asyncio.create_task(fetch_and_cache_feed(feed_id, url))
+    return {"data": {"id": feed_id, "url": url, "message": "Feed added and fetching started."}}
+
+
+@tool(
+    name="read_article",
+    description=(
+        "Fetch and read the full text of a web page or article from a URL. "
+        "Use when the user shares a URL and wants you to read it, "
+        "or to get the full content of a linked page. "
+        "Do NOT use lookup for URLs — use this tool instead."
+    ),
+    parameters={
+        "url": {"type": "string", "description": "The URL to fetch and read"},
+    },
+    required=["url"],
+    read_only=True,
+    briefing=True,
+)
+async def read_article_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.rss import _fetch_full_article
+
+    url = arguments.get("url", "").strip()
+    if not url:
+        return {"success": False, "error": "No URL provided"}
+    content = await _fetch_full_article(url)
+    if not content:
+        return {"success": False, "error": f"Could not fetch article content from {url}"}
+    _TOOL_CONTENT_CAP = 40_000
+    truncated = len(content) > _TOOL_CONTENT_CAP
+    return {
+        "success": True,
+        "type": "article_content",
+        "url": url,
+        "content": content[:_TOOL_CONTENT_CAP],
+        "truncated": truncated,
+    }

src/fabledassistant/services/tools/tasks.py

@@ -0,0 +1,116 @@
+"""Task tools: list, log work."""
+
+from __future__ import annotations
+
+from fabledassistant.services.notes import get_note_by_title, list_notes
+from fabledassistant.services.tools._helpers import (
+    parse_due_date,
+    resolve_project,
+)
+from fabledassistant.services.tools._registry import tool
+
+
+@tool(
+    name="list_tasks",
+    description="List tasks with optional filters. For overdue tasks, set due_before to today's date.",
+    parameters={
+        "q": {"type": "string", "description": "Optional keyword filter — searches title and body"},
+        "status": {"type": "array", "items": {"type": "string", "enum": ["todo", "in_progress", "done", "cancelled"]}, "description": "Filter by one or more statuses. Omit for all."},
+        "priority": {"type": "string", "enum": ["none", "low", "medium", "high"], "description": "Filter by priority level"},
+        "due_before": {"type": "string", "description": "Return tasks due before this date (YYYY-MM-DD). Use today's date to find overdue tasks."},
+        "due_after": {"type": "string", "description": "Return tasks due on or after this date (YYYY-MM-DD)"},
+        "project": {"type": "string", "description": "Filter tasks by project name"},
+        "milestone": {"type": "string", "description": "Filter tasks by milestone name within a project"},
+        "limit": {"type": "integer", "description": "Maximum number of tasks to return (default 10)"},
+    },
+    read_only=True,
+    briefing=True,
+)
+async def list_tasks_tool(*, user_id, arguments, **_ctx):
+    project_id = None
+    milestone_id = None
+    project_name = arguments.get("project")
+    milestone_name = arguments.get("milestone")
+    if project_name:
+        proj = await resolve_project(user_id, project_name)
+        if proj:
+            project_id = proj.id
+            if milestone_name:
+                from fabledassistant.services.milestones import get_milestone_by_title
+                ms = await get_milestone_by_title(user_id, proj.id, milestone_name)
+                if ms:
+                    milestone_id = ms.id
+    elif milestone_name:
+        from fabledassistant.services.milestones import find_milestone_by_title
+        ms = await find_milestone_by_title(user_id, milestone_name)
+        if ms:
+            milestone_id = ms.id
+    notes, total = await list_notes(
+        user_id=user_id,
+        q=arguments.get("q") or None,
+        is_task=True,
+        status=arguments.get("status"),
+        priority=arguments.get("priority"),
+        due_before=parse_due_date(arguments.get("due_before")),
+        due_after=parse_due_date(arguments.get("due_after")),
+        project_id=project_id,
+        milestone_id=milestone_id,
+        exclude_paused_projects=project_id is None,
+        limit=int(arguments.get("limit", 10)),
+        sort="due_date",
+        order="asc",
+    )
+    results = []
+    for n in notes:
+        results.append({
+            "id": n.id,
+            "title": n.title,
+            "status": n.status,
+            "priority": n.priority,
+            "due_date": str(n.due_date) if n.due_date else None,
+            "project_id": n.project_id,
+            "preview": (n.body[:120] + "...") if n.body and len(n.body) > 120 else (n.body or ""),
+        })
+    return {
+        "success": True,
+        "type": "tasks",
+        "data": {"total": total, "count": len(results), "results": results},
+    }
+
+
+@tool(
+    name="log_work",
+    description="Add a work log entry to a task to record progress, work done, or time spent. Use this when the user says they worked on, completed, or spent time on a task.",
+    parameters={
+        "task": {"type": "string", "description": "Title or keyword identifying the task (required)"},
+        "content": {"type": "string", "description": "Description of the work done (required)"},
+        "duration_minutes": {"type": "integer", "description": "Optional time spent in minutes"},
+    },
+    required=["task", "content"],
+)
+async def log_work_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.task_logs import create_log as _create_log
+
+    task_query = arguments.get("task", "")
+    content = arguments.get("content", "").strip()
+    if not task_query:
+        return {"success": False, "error": "task is required"}
+    if not content:
+        return {"success": False, "error": "content is required"}
+    duration_minutes = arguments.get("duration_minutes")
+    if duration_minutes is not None:
+        try:
+            duration_minutes = int(duration_minutes)
+        except (TypeError, ValueError):
+            duration_minutes = None
+    note = await get_note_by_title(user_id, task_query)
+    if note is None or note.status is None:
+        notes, _ = await list_notes(user_id=user_id, q=task_query, is_task=True, limit=5)
+        note = notes[0] if notes else None
+    if note is None:
+        return {"success": False, "error": f"No task found matching '{task_query}'."}
+    try:
+        log = await _create_log(user_id, note.id, content, duration_minutes)
+    except ValueError as e:
+        return {"success": False, "error": str(e)}
+    return {"success": True, "log": log.to_dict(), "task": note.title}

src/fabledassistant/services/tools/utility.py

@@ -0,0 +1,34 @@
+"""General-purpose utility tools."""
+
+from __future__ import annotations
+
+from fabledassistant.services.tools._registry import tool
+
+
+@tool(
+    name="calculate",
+    description=(
+        "Evaluate a mathematical expression and return the exact result. Use this for any "
+        "arithmetic, percentages, unit conversions, or multi-step calculations where precision "
+        "matters. Supports standard math operators (+, -, *, /, **, %) and all Python math "
+        "module functions (sqrt, log, sin, cos, floor, ceil, etc.)."
+    ),
+    parameters={
+        "expression": {"type": "string", "description": "A valid Python math expression (e.g. '(450 * 1.13) / 12', 'sqrt(144)', 'log(1000, 10)')"},
+    },
+    required=["expression"],
+)
+async def calculate_tool(*, user_id, arguments, **_ctx):
+    import math as _math
+
+    expr = str(arguments.get("expression", "")).strip()
+    if not expr:
+        return {"success": False, "error": "expression is required"}
+    allowed_names = {k: v for k, v in vars(_math).items() if not k.startswith("_")}
+    allowed_names["abs"] = abs
+    allowed_names["round"] = round
+    try:
+        result = eval(expr, {"__builtins__": {}}, allowed_names)  # noqa: S307
+    except Exception as calc_err:
+        return {"success": False, "error": f"Could not evaluate expression: {calc_err}"}
+    return {"success": True, "type": "calculation", "data": {"expression": expr, "result": result}}

src/fabledassistant/services/tools/weather.py

@@ -0,0 +1,122 @@
+"""Weather tool."""
+
+from __future__ import annotations
+
+import json as _wx_json
+import logging
+from datetime import datetime, timedelta, timezone
+
+from fabledassistant.services.tools._registry import tool
+
+logger = logging.getLogger(__name__)
+
+
+@tool(
+    name="get_weather",
+    description=(
+        "Get the weather forecast. By default returns today only — use days=7 when the user "
+        "explicitly asks for a multi-day forecast or 'this week'. "
+        "Pass a city/region name to look up any location, or omit to get the user's configured home/work locations."
+    ),
+    parameters={
+        "location": {"type": "string", "description": "City/region to look up, or 'home'/'work' for saved locations. Omit for all saved."},
+        "days": {"type": "integer", "description": "Number of days to return (1–8). Default 1 (today only). Use 7 or 8 when the user asks for a weekly forecast or multiple days."},
+    },
+    read_only=True,
+    briefing=True,
+)
+async def get_weather_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.briefing_pipeline import _get_temp_unit
+    from fabledassistant.services.weather import (
+        _fetch_open_meteo,
+        geocode,
+        get_cached_weather,
+        parse_forecast,
+        refresh_location_cache,
+    )
+
+    location = (arguments.get("location") or "").strip()
+    num_days = max(1, min(8, int(arguments.get("days") or 1)))
+    temp_unit = await _get_temp_unit(user_id)
+
+    def _apply_unit(days: list[dict]) -> list[dict]:
+        if temp_unit != "F":
+            return days
+        def _c_to_f(v: float | None) -> float | None:
+            return round(v * 9 / 5 + 32, 1) if v is not None else None
+        return [
+            {**d, "temp_max": _c_to_f(d.get("temp_max")), "temp_min": _c_to_f(d.get("temp_min"))}
+            for d in days
+        ]
+
+    _known = {"home", "work", "all", ""}
+    if location.lower() not in _known:
+        try:
+            lat, lon, label = await geocode(location)
+            raw = await _fetch_open_meteo(lat, lon)
+            days = _apply_unit(parse_forecast(raw))[:num_days]
+            return {"success": True, "data": {"locations": [{
+                "location_key": "query",
+                "location_label": label,
+                "fetched_at": datetime.now(timezone.utc).isoformat(),
+                "days": days,
+                "temp_unit": temp_unit,
+                "changes_since_last_fetch": [],
+            }]}}
+        except Exception as e:
+            return {"success": False, "error": f"Could not get weather for '{location}': {e}"}
+
+    locations = await get_cached_weather(user_id)
+    if location.lower() not in ("all", ""):
+        locations = [loc for loc in locations if loc["location_key"] == location.lower()]
+    now_utc = datetime.now(timezone.utc)
+    stale_cutoff = now_utc - timedelta(hours=6)
+    stale_keys = []
+    for loc in locations:
+        try:
+            fetched = datetime.fromisoformat(loc.get("fetched_at", ""))
+        except Exception:
+            fetched = None
+        if fetched is None or fetched < stale_cutoff:
+            stale_keys.append(loc["location_key"])
+    if stale_keys:
+        try:
+            from fabledassistant.services.settings import get_setting as _wx_get_setting
+            raw_cfg = await _wx_get_setting(user_id, "briefing_config", "{}")
+            cfg = _wx_json.loads(raw_cfg) if isinstance(raw_cfg, str) else (raw_cfg or {})
+            cfg_locs = cfg.get("locations", {}) if isinstance(cfg, dict) else {}
+            for key in stale_keys:
+                meta = cfg_locs.get(key) or {}
+                if meta.get("lat") and meta.get("lon"):
+                    try:
+                        await refresh_location_cache(
+                            user_id=user_id,
+                            location_key=key,
+                            location_label=meta.get("label", key),
+                            lat=meta["lat"],
+                            lon=meta["lon"],
+                        )
+                    except Exception:
+                        logger.debug("Weather refresh failed for %s", key, exc_info=True)
+            locations = await get_cached_weather(user_id)
+            if location.lower() not in ("all", ""):
+                locations = [loc for loc in locations if loc["location_key"] == location.lower()]
+        except Exception:
+            logger.debug("Weather staleness refresh failed", exc_info=True)
+
+    stamped_locations = []
+    for loc in locations:
+        days = _apply_unit(loc.get("days", []))[:num_days]
+        try:
+            fetched = datetime.fromisoformat(loc.get("fetched_at", ""))
+            age_h = (now_utc - fetched).total_seconds() / 3600.0
+        except Exception:
+            age_h = None
+        stamped_locations.append({
+            **loc,
+            "days": days,
+            "temp_unit": temp_unit,
+            "cache_age_hours": round(age_h, 1) if age_h is not None else None,
+            "is_stale": age_h is not None and age_h > 12.0,
+        })
+    return {"success": True, "data": {"locations": stamped_locations}}

src/fabledassistant/services/tools/web.py

@@ -0,0 +1,195 @@
+"""Web search, research, and image tools."""
+
+from __future__ import annotations
+
+import logging
+
+from fabledassistant.services.tools._registry import tool
+
+logger = logging.getLogger(__name__)
+
+
+@tool(
+    name="lookup",
+    description=(
+        "Look up a topic, concept, or factual question. Returns a concise answer from "
+        "Wikipedia or web sources. Use for definitions, explanations, 'what is X', "
+        "'how does Y work', current events, or version numbers. No note is saved. "
+        "For comprehensive written reports saved as notes, use research_topic instead."
+    ),
+    parameters={
+        "query": {"type": "string", "description": "The topic or question to look up"},
+    },
+    required=["query"],
+)
+async def lookup_tool(*, user_id, arguments, **_ctx):
+    import asyncio
+
+    from fabledassistant.config import Config
+    from fabledassistant.services.wikipedia import wiki_summary
+
+    query = arguments.get("query", "").strip()
+    if not query:
+        return {"success": False, "error": "query is required"}
+
+    searxng_enabled = Config.searxng_enabled()
+
+    async def _searxng_results() -> list[dict]:
+        if not searxng_enabled:
+            return []
+        from fabledassistant.services.research import _search_searxng
+        return await _search_searxng(query) or []
+
+    wiki, search_results = await asyncio.gather(
+        wiki_summary(query),
+        _searxng_results(),
+    )
+
+    wiki_payload: dict | None = None
+    if wiki:
+        wiki_payload = {
+            "title": wiki["title"],
+            "extract": wiki["extract"],
+            "url": wiki["url"],
+        }
+        thumb_url = wiki.get("thumbnail_url") or ""
+        if thumb_url:
+            from fabledassistant.services.images import fetch_and_store_image
+            record = await fetch_and_store_image(
+                url=thumb_url,
+                title=wiki["title"],
+                source_domain="en.wikipedia.org",
+            )
+            if record:
+                wiki_payload["image"] = {
+                    "embed": f"![{wiki['title']}](/api/images/{record.id})",
+                    "citation": f"*Source: [Wikipedia]({wiki['url']})*",
+                }
+
+    web_payload: list[dict] = []
+    if search_results:
+        # Sequential fetches: trafilatura/lxml is not safe to run concurrently
+        # via run_in_executor — parallel calls can trip a libxml2 double-free.
+        from fabledassistant.services.rss import _fetch_full_article
+
+        for r in search_results[:2]:
+            url = r.get("url", "")
+            if not url:
+                continue
+            try:
+                content = await _fetch_full_article(url)
+            except Exception:
+                content = None
+            web_payload.append({
+                "url": url,
+                "title": r.get("title", url),
+                "snippet": r.get("snippet", ""),
+                "content": (content or "")[:4000],
+            })
+
+    if not wiki_payload and not web_payload:
+        return {
+            "success": True,
+            "type": "lookup",
+            "data": {
+                "query": query,
+                "message": "No results found. You can answer from your own knowledge.",
+            },
+        }
+
+    data: dict = {
+        "query": query,
+        "wikipedia": wiki_payload,
+        "web": web_payload,
+    }
+    if wiki_payload and wiki_payload.get("image"):
+        data["image_instructions"] = (
+            "If an image is relevant to your reply, embed it by writing the wikipedia.image.embed "
+            "field verbatim, then the citation field on the next line. Otherwise omit it."
+        )
+    return {
+        "success": True,
+        "type": "lookup",
+        "data": data,
+    }
+
+
+@tool(
+    name="research_topic",
+    description=(
+        "Deep web research — searches multiple sources, synthesizes findings, and saves the result "
+        "as a structured note with sections and citations. Use when the user says 'research', "
+        "'look into', or wants a comprehensive write-up. Takes 30–120 seconds. "
+        "For a quick factual answer without saving a note, use lookup."
+    ),
+    parameters={
+        "topic": {"type": "string", "description": "The topic or question to research"},
+    },
+    required=["topic"],
+    requires="searxng",
+)
+async def research_topic_tool(*, user_id, arguments, **_ctx):
+    # Research is always intercepted in generation_task.py (round 0) before execute_tool.
+    # Reaching here indicates a code path regression.
+    topic = arguments.get("topic", "")
+    logger.error(
+        "research_topic reached execute_tool — should have been intercepted upstream "
+        "in generation_task.py. topic=%r",
+        topic,
+    )
+    return {"success": False, "error": "Research could not be started. Please try again."}
+
+
+@tool(
+    name="search_images",
+    description="Search and display images inline. Use ONLY when the user explicitly asks to see, show, or find an image or photo. Not for factual questions — use lookup for those.",
+    parameters={
+        "query": {"type": "string", "description": "The image search query"},
+    },
+    required=["query"],
+    requires="searxng",
+)
+async def search_images_tool(*, user_id, arguments, **_ctx):
+    from fabledassistant.services.images import fetch_and_store_image
+    from fabledassistant.services.research import _search_searxng_images
+
+    query = arguments.get("query", "")
+    if not query:
+        return {"success": False, "error": "query is required"}
+    raw_results = await _search_searxng_images(query)
+    if not raw_results:
+        return {"success": False, "error": f"No images found for '{query}'"}
+    images = []
+    for r in raw_results[:2]:
+        img_url = r.get("img_src", "")
+        if not img_url:
+            continue
+        record = await fetch_and_store_image(
+            url=img_url,
+            title=r.get("title"),
+            source_domain=r.get("source_domain"),
+        )
+        if record:
+            title = record.title or query
+            page_url = r.get("page_url", "")
+            source_domain = r.get("source_domain", "")
+            images.append({
+                "embed": f"![{title}](/api/images/{record.id})",
+                "citation": f"*Source: [{source_domain or 'image'}]({page_url})*",
+                "page_url": page_url,
+                "title": title,
+            })
+    if not images:
+        return {"success": False, "error": f"Could not retrieve images for '{query}'"}
+    return {
+        "success": True,
+        "type": "image_search",
+        "data": {
+            "query": query,
+            "images": images,
+            "instructions": (
+                "Embed each image in your response by writing the 'embed' field verbatim, "
+                "then the 'citation' field on the next line. Do not paraphrase or list URLs."
+            ),
+        },
+    }

src/fabledassistant/services/tz.py

@@ -0,0 +1,47 @@
+"""User-timezone helpers.
+
+All datetimes in the DB are stored as UTC. The helpers here bridge between
+that UTC storage and the user's configured local timezone (IANA string in
+the ``user_timezone`` setting). Use these anywhere the model or UI talks
+in terms of "today", "tomorrow", or a bare calendar date — never
+``date.today()`` or ``datetime.now(timezone.utc)`` inside a per-user flow.
+"""
+from __future__ import annotations
+
+from datetime import date, datetime, timedelta
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from fabledassistant.services.settings import get_setting
+
+# Briefing day boundary — kept in sync with the compilation slot in
+# ``briefing_scheduler.SLOTS``. The briefing day flips at this local hour
+# (not midnight) so the 00:00–04:00 local window still shows yesterday's
+# briefing until the 4am compilation generates the new one.
+BRIEFING_DAY_START_HOUR = 4
+
+
+async def get_user_tz(user_id: int) -> ZoneInfo:
+    """Return the user's IANA ``ZoneInfo``, falling back to UTC."""
+    tz_str = await get_setting(user_id, "user_timezone") or "UTC"
+    try:
+        return ZoneInfo(tz_str)
+    except (ZoneInfoNotFoundError, KeyError):
+        return ZoneInfo("UTC")
+
+
+async def user_today(user_id: int) -> date:
+    """Return today's calendar date in the user's local timezone."""
+    tz = await get_user_tz(user_id)
+    return datetime.now(tz).date()
+
+
+async def user_briefing_date(user_id: int) -> date:
+    """Return the current "briefing day" in the user's local timezone.
+
+    The briefing day flips at ``BRIEFING_DAY_START_HOUR`` (4am local),
+    aligned with the compilation slot that generates the day's briefing.
+    Between 00:00 and 04:00 local this still returns *yesterday*, so the
+    UI keeps showing the in-progress briefing until the new one is built.
+    """
+    tz = await get_user_tz(user_id)
+    return (datetime.now(tz) - timedelta(hours=BRIEFING_DAY_START_HOUR)).date()

src/fabledassistant/services/user_profile.py

@@ -114,7 +114,7 @@ async def _consolidate_observations(user_id: int) -> str:
     learned_summary paragraph. Prunes raw entries older than 30 days afterwards.
     """
     from fabledassistant.config import Config
-    from fabledassistant.services.briefing_pipeline import _llm_synthesise
+    from fabledassistant.services.llm import generate_completion
     from fabledassistant.services.settings import get_setting
 
     async with async_session() as session:
@@ -145,7 +145,17 @@ async def _consolidate_observations(user_id: int) -> str:
     user_prompt += f"New observations:\n{obs_text}"
 
     model = await get_setting(user_id, "default_model", Config.OLLAMA_MODEL)
-    new_summary = await _llm_synthesise(system, user_prompt, model)
+    try:
+        new_summary = (await generate_completion(
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user_prompt},
+            ],
+            model,
+        )).strip()
+    except Exception:
+        logger.warning("Observation consolidation failed for user %d", user_id, exc_info=True)
+        new_summary = ""
 
     if new_summary:
         cutoff = (date.today() - timedelta(days=30)).isoformat()

src/fabledassistant/services/weather.py

@@ -17,6 +17,7 @@ OPEN_METEO_DAILY = (
     "temperature_2m_max,temperature_2m_min,precipitation_sum,"
     "precipitation_probability_max,weathercode,windspeed_10m_max"
 )
+OPEN_METEO_HOURLY = "precipitation_probability"
 
 # WMO weather code → description (subset; covers the most common codes)
 _WMO_CODES: dict[int, str] = {
@@ -93,6 +94,55 @@ def detect_changes(old_days: list[dict], new_days: list[dict]) -> list[str]:
     return changes
 
 
+def _summarize_precip(hourly_probs: list[tuple[int, int]], threshold: int = 30) -> str | None:
+    """Build a human-readable precipitation summary from (hour, probability) pairs.
+
+    Returns None when no significant precipitation is expected.
+    """
+    wet_hours = [(h, p) for h, p in hourly_probs if p >= threshold]
+    if not wet_hours:
+        return None
+
+    peak_hour, peak_prob = max(wet_hours, key=lambda x: x[1])
+    daytime_hours = [h for h, _ in hourly_probs if 6 <= h <= 22]
+    if not daytime_hours:
+        return None
+
+    wet_daytime = [h for h, p in hourly_probs if 6 <= h <= 22 and p >= threshold]
+    if len(wet_daytime) >= 10:
+        return f"Rain likely all day (up to {peak_prob}%)"
+
+    if not wet_daytime:
+        return None
+
+    def _fmt_hour(h: int) -> str:
+        if h == 0 or h == 24:
+            return "12 AM"
+        if h == 12:
+            return "12 PM"
+        return f"{h} AM" if h < 12 else f"{h - 12} PM"
+
+    start = wet_daytime[0]
+    end = wet_daytime[-1]
+    if start == end:
+        return f"{peak_prob}% chance around {_fmt_hour(start)}"
+    return f"Rain likely {_fmt_hour(start)}–{_fmt_hour(end + 1)} (up to {peak_prob}%)"
+
+
+def _extract_hourly_precip_for_date(raw: dict, date_str: str) -> list[tuple[int, int]]:
+    """Extract (hour, probability) pairs for a specific date from cached forecast JSON."""
+    hourly = raw.get("hourly", {})
+    times = hourly.get("precipitation_probability", [])
+    time_labels = hourly.get("time", [])
+    pairs: list[tuple[int, int]] = []
+    prefix = date_str + "T"
+    for i, t in enumerate(time_labels):
+        if t.startswith(prefix) and i < len(times) and times[i] is not None:
+            hour = int(t[11:13])
+            pairs.append((hour, times[i]))
+    return pairs
+
+
 def parse_weather_card_data(
     cache_row,
     temp_unit: str = "C",
@@ -138,6 +188,30 @@ def parse_weather_card_data(
 
     wind_unit = "mph" if imperial else "km/h"
 
+    today_hourly = _extract_hourly_precip_for_date(raw, today_str)
+    today_precip_summary = _summarize_precip(today_hourly)
+
+    def _forecast_day(d: dict) -> dict:
+        entry: dict = {
+            "day": day_label(d["date"]),
+            "condition": d["description"],
+            "high": to_temp(d["temp_max"]),
+            "low": to_temp(d["temp_min"]),
+            "precip_probability": d["precip_probability"],
+            "precip_mm": d["precip_mm"],
+            "windspeed_max": to_wind(d["windspeed_max"]),
+        }
+        hourly = _extract_hourly_precip_for_date(raw, d["date"])
+        summary = _summarize_precip(hourly)
+        if summary:
+            entry["precip_summary"] = summary
+        if hourly:
+            peak = max(hourly, key=lambda x: x[1])
+            if peak[1] >= 30:
+                h = peak[0]
+                entry["precip_peak_hour"] = f"{h} AM" if h < 12 else ("12 PM" if h == 12 else f"{h - 12} PM")
+        return entry
+
     return {
         "location": getattr(cache_row, "location_label", ""),
         "fetched_at": cache_row.fetched_at.isoformat(),
@@ -148,18 +222,8 @@ def parse_weather_card_data(
         "yesterday_high": to_temp(yesterday_day["temp_max"]) if yesterday_day else None,
         "yesterday_low": to_temp(yesterday_day["temp_min"]) if yesterday_day else None,
         "wind_unit": wind_unit,
-        "forecast": [
-            {
-                "day": day_label(d["date"]),
-                "condition": d["description"],
-                "high": to_temp(d["temp_max"]),
-                "low": to_temp(d["temp_min"]),
-                "precip_probability": d["precip_probability"],
-                "precip_mm": d["precip_mm"],
-                "windspeed_max": to_wind(d["windspeed_max"]),
-            }
-            for d in future_days
-        ],
+        "precip_summary": today_precip_summary,
+        "forecast": [_forecast_day(d) for d in future_days],
     }
 
 
@@ -184,13 +248,88 @@ async def geocode(query: str) -> tuple[float, float, str]:
         return float(r["lat"]), float(r["lon"]), r.get("display_name", query)
 
 
+async def fetch_current_conditions(lat: float, lon: float) -> dict | None:
+    """Fetch current temperature + conditions + next 3 hours precipitation.
+
+    Lightweight call — no daily forecast, no caching needed.
+    Returns dict with: temperature, windspeed, weathercode, description,
+    and precip_next_3h (list of hourly precip probabilities).
+    """
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(OPEN_METEO_URL, params={
+                "latitude": lat,
+                "longitude": lon,
+                "current_weather": "true",
+                "hourly": "precipitation_probability",
+                "forecast_days": 1,
+                "timezone": "auto",
+            })
+            resp.raise_for_status()
+            data = resp.json()
+
+        current = data.get("current_weather", {})
+        hourly = data.get("hourly", {})
+        hourly_times = hourly.get("time", [])
+        hourly_precip = hourly.get("precipitation_probability", [])
+
+        # Find the current hour index and get next 3 hours of precip
+        current_time = current.get("time", "")
+        precip_next_3h = []
+        try:
+            idx = next(i for i, t in enumerate(hourly_times) if t >= current_time)
+            precip_next_3h = hourly_precip[idx:idx + 3]
+        except (StopIteration, IndexError):
+            pass
+
+        code = current.get("weathercode", 0)
+        return {
+            "temperature": current.get("temperature"),
+            "windspeed": current.get("windspeed"),
+            "weathercode": code,
+            "description": describe_weathercode(code),
+            "time": current_time,
+            "precip_next_3h": precip_next_3h,
+        }
+    except Exception:
+        logger.debug("Failed to fetch current conditions for %s, %s", lat, lon, exc_info=True)
+        return None
+
+
+async def fetch_hourly_precip(lat: float, lon: float) -> dict[str, int]:
+    """Fetch today's hourly precipitation probabilities.
+
+    Returns a dict of ISO hour string → probability percentage, e.g.:
+    {"2026-04-08T14:00": 65, "2026-04-08T15:00": 80, ...}
+    """
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.get(OPEN_METEO_URL, params={
+                "latitude": lat,
+                "longitude": lon,
+                "hourly": "precipitation_probability",
+                "forecast_days": 1,
+                "timezone": "auto",
+            })
+            resp.raise_for_status()
+            data = resp.json()
+        hourly = data.get("hourly", {})
+        times = hourly.get("time", [])
+        probs = hourly.get("precipitation_probability", [])
+        return {t: p for t, p in zip(times, probs) if p is not None}
+    except Exception:
+        logger.debug("Failed to fetch hourly precip for %s, %s", lat, lon, exc_info=True)
+        return {}
+
+
 async def _fetch_open_meteo(lat: float, lon: float) -> dict:
-    """Fetch 7-day forecast from Open-Meteo with current conditions and yesterday's data."""
+    """Fetch 7-day forecast from Open-Meteo with current conditions, hourly precip, and yesterday's data."""
     async with httpx.AsyncClient(timeout=15.0) as client:
         resp = await client.get(OPEN_METEO_URL, params={
             "latitude": lat,
             "longitude": lon,
             "daily": OPEN_METEO_DAILY,
+            "hourly": OPEN_METEO_HOURLY,
             "current_weather": "true",
             "past_days": 1,
             "timezone": "auto",

src/fabledassistant/services/wikipedia.py

@@ -0,0 +1,113 @@
+"""Wikipedia API: lightweight topic lookups and article search."""
+import logging
+from urllib.parse import quote as url_quote
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_SUMMARY_URL = "https://en.wikipedia.org/api/rest_v1/page/summary"
+_SEARCH_URL = "https://en.wikipedia.org/w/api.php"
+_TIMEOUT = 5.0
+_USER_AGENT = "FabledAssistant/1.0 (https://fabledsword.com)"
+
+
+def _extract_thumbnail(data: dict) -> str:
+    """Prefer the 320px thumbnail (kinder to cache/bandwidth) over originalimage."""
+    thumb = data.get("thumbnail", {}).get("source", "")
+    if thumb:
+        return thumb
+    return data.get("originalimage", {}).get("source", "")
+
+
+async def wiki_summary(query: str) -> dict | None:
+    """Fetch a Wikipedia summary for a given title/query.
+
+    Does a direct title lookup via the REST v1 summary endpoint.
+    Returns a dict with title, extract, url, and thumbnail_url on success;
+    thumbnail_url is an empty string when the article has no image.
+    Returns None on any failure.
+    """
+    title = url_quote(query.replace(" ", "_"))
+    url = f"{_SUMMARY_URL}/{title}"
+    headers = {"User-Agent": _USER_AGENT}
+    try:
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(url, headers=headers, timeout=_TIMEOUT, follow_redirects=True)
+            resp.raise_for_status()
+            data = resp.json()
+            if data.get("type") == "disambiguation":
+                logger.debug("wiki_summary: disambiguation page for %r", query)
+                return None
+            extract = data.get("extract", "").strip()
+            if not extract:
+                logger.debug("wiki_summary: empty extract for %r", query)
+                return None
+            return {
+                "title": data.get("title", query),
+                "extract": extract,
+                "url": data.get("content_urls", {}).get("desktop", {}).get("page", ""),
+                "thumbnail_url": _extract_thumbnail(data),
+            }
+    except Exception as exc:
+        logger.debug("wiki_summary failed for %r: %s", query, exc)
+        return None
+
+
+async def wiki_search(query: str, limit: int = 3) -> list[dict]:
+    """Search Wikipedia and return summaries for the top results.
+
+    Uses the MediaWiki search API then fetches summaries for each hit.
+    Skips disambiguation pages and empty extracts.
+    Returns a list of dicts with title, extract, and url.
+    """
+    headers = {"User-Agent": _USER_AGENT}
+    params = {
+        "action": "query",
+        "list": "search",
+        "srsearch": query,
+        "srlimit": str(limit),
+        "format": "json",
+    }
+    results: list[dict] = []
+    try:
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(
+                _SEARCH_URL, params=params, headers=headers, timeout=_TIMEOUT
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            hits = data.get("query", {}).get("search", [])
+            for hit in hits:
+                title = hit.get("title", "")
+                encoded = url_quote(title.replace(" ", "_"))
+                summary_url = f"{_SUMMARY_URL}/{encoded}"
+                try:
+                    sr = await client.get(
+                        summary_url, headers=headers, timeout=_TIMEOUT, follow_redirects=True
+                    )
+                    sr.raise_for_status()
+                    sdata = sr.json()
+                    if sdata.get("type") == "disambiguation":
+                        logger.debug("wiki_search: skipping disambiguation %r", title)
+                        continue
+                    extract = sdata.get("extract", "").strip()
+                    if not extract:
+                        logger.debug("wiki_search: empty extract for %r", title)
+                        continue
+                    results.append(
+                        {
+                            "title": sdata.get("title", title),
+                            "extract": extract,
+                            "url": sdata.get("content_urls", {})
+                            .get("desktop", {})
+                            .get("page", ""),
+                            "thumbnail_url": _extract_thumbnail(sdata),
+                        }
+                    )
+                except Exception as exc:
+                    logger.debug("wiki_search: summary fetch failed for %r: %s", title, exc)
+    except Exception as exc:
+        logger.debug("wiki_search failed for %r: %s", query, exc)
+        return []
+    return results

tests/test_article_reading.py

@@ -134,3 +134,83 @@ def test_history_builder_no_tool_calls_unchanged():
     assert len(history) == 2
     assert history[0] == {"role": "user", "content": "Hello"}
     assert history[1] == {"role": "assistant", "content": "Hi there!"}
+
+
+# ---------------------------------------------------------------------------
+# prepare_article_context tests
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_prepare_article_context_small_passthrough():
+    """Articles under CHAR_BUDGET pass through unchanged with zero LLM calls."""
+    from fabledassistant.services import article_context
+
+    body = "A short article.\n\nWith two paragraphs."
+    with patch(
+        "fabledassistant.services.article_context.generate_completion",
+        new_callable=AsyncMock,
+    ) as mock_gen:
+        out = await article_context.prepare_article_context(
+            "Title", "https://example.com", body, "test-model",
+        )
+
+    assert out == body
+    mock_gen.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_prepare_article_context_large_runs_map_reduce():
+    """Articles over CHAR_BUDGET are chunked and map-reduced via the background model."""
+    from fabledassistant.services import article_context
+
+    # CHAR_BUDGET is 48_000 — build a body well over that with paragraph breaks
+    # so the chunker has natural splits to work with.
+    paragraph = ("Lorem ipsum dolor sit amet, consectetur adipiscing elit. " * 40).strip()
+    body = "\n\n".join([paragraph] * 30)  # ~70k+ chars across 30 paragraphs
+    assert len(body) > article_context.CHAR_BUDGET
+
+    with patch(
+        "fabledassistant.services.article_context.generate_completion",
+        new_callable=AsyncMock,
+        return_value="Summary of this section with specific claims preserved.",
+    ) as mock_gen:
+        out = await article_context.prepare_article_context(
+            "Long Article", "https://example.com/long", body, "test-model",
+        )
+
+    # At least one LLM call fired (the map step ran)
+    assert mock_gen.await_count >= 1
+    # Output carries the oversized-article header and section markers
+    assert "longer than the chat window" in out
+    assert "## Section 1" in out
+    # Map output is much smaller than the raw body
+    assert len(out) < len(body)
+
+
+def test_chunk_by_paragraph_respects_boundaries():
+    """Chunker splits on paragraph breaks, not mid-sentence."""
+    from fabledassistant.services.article_context import _chunk_by_paragraph, CHUNK_CHARS
+
+    paragraphs = [f"Paragraph {i}. " + ("x" * 1000) for i in range(20)]
+    body = "\n\n".join(paragraphs)
+
+    chunks = _chunk_by_paragraph(body)
+
+    # Each chunk stays under the budget
+    for chunk in chunks:
+        assert len(chunk) <= CHUNK_CHARS
+    # Total content is preserved (modulo overlap duplication, so ≥ original)
+    assert sum(len(c) for c in chunks) >= len(body) * 0.9
+
+
+def test_chunk_by_paragraph_handles_oversized_paragraph():
+    """A single paragraph larger than CHUNK_CHARS gets split mid-paragraph."""
+    from fabledassistant.services.article_context import _chunk_by_paragraph, CHUNK_CHARS
+
+    body = "x" * (CHUNK_CHARS * 3)  # one huge paragraph, no breaks
+    chunks = _chunk_by_paragraph(body)
+
+    assert len(chunks) >= 3
+    for chunk in chunks:
+        assert len(chunk) <= CHUNK_CHARS

tests/test_briefing_pipeline.py

@@ -12,52 +12,6 @@ async def test_get_or_create_profile_note_returns_body():
         assert body == ""
 
 
-def test_format_task_for_briefing():
-    """format_task() should return a compact single-line string."""
-    from fabledassistant.services.briefing_pipeline import format_task
-    task = {"title": "Write design doc", "status": "in_progress", "due_date": "2026-03-12", "priority": "high"}
-    result = format_task(task)
-    assert "Write design doc" in result
-    assert "in_progress" in result or "In Progress" in result
-
-
-
-def test_compute_task_snapshot_hash():
-    """compute_task_hash should return a stable SHA-256 hex string."""
-    from fabledassistant.services.briefing_pipeline import compute_task_hash
-
-    task = {"status": "todo", "priority": "high", "due_date": "2026-03-25", "title": "Write spec"}
-    h = compute_task_hash(task)
-    assert len(h) == 64  # SHA-256 hex
-    assert h == compute_task_hash(task)
-    assert h != compute_task_hash({**task, "status": "done"})
-
-
-@pytest.mark.asyncio
-async def test_split_changed_tasks_all_new():
-    """split_changed_tasks should return all tasks as changed when no snapshot exists."""
-    from fabledassistant.services.briefing_pipeline import split_changed_tasks
-
-    tasks = [
-        {"task_id": 1, "title": "A", "status": "todo", "priority": "none", "due_date": None},
-    ]
-
-    with patch(
-        "fabledassistant.services.briefing_pipeline.async_session"
-    ) as mock_cls:
-        mock_session = AsyncMock()
-        mock_session.__aenter__ = AsyncMock(return_value=mock_session)
-        mock_session.__aexit__ = AsyncMock(return_value=False)
-        mock_session.execute = AsyncMock(return_value=MagicMock(
-            scalars=MagicMock(return_value=MagicMock(all=MagicMock(return_value=[])))
-        ))
-        mock_cls.return_value = mock_session
-
-        changed, unchanged_count = await split_changed_tasks(user_id=1, tasks=tasks)
-        assert len(changed) == 1
-        assert unchanged_count == 0
-
-
 @pytest.mark.asyncio
 async def test_post_message_accepts_metadata():
     """post_message should accept an optional metadata dict and store it."""

tests/test_briefing_scheduler.py

@@ -84,7 +84,7 @@ async def test_run_slot_morning_runs_on_work_day():
          patch("fabledassistant.services.user_profile.get_profile", new_callable=AsyncMock, return_value=fake_profile), \
          patch("fabledassistant.services.settings.get_setting", new_callable=AsyncMock, return_value="UTC"), \
          patch("fabledassistant.services.briefing_conversations.get_or_create_today_conversation", new_callable=AsyncMock) as mock_conv, \
-         patch("fabledassistant.services.briefing_pipeline.run_slot_injection", new_callable=AsyncMock, return_value="") as mock_inject, \
+         patch("fabledassistant.services.briefing_pipeline.run_slot_injection", new_callable=AsyncMock, return_value=("", {})) as mock_inject, \
          patch("fabledassistant.services.briefing_conversations.post_message", new_callable=AsyncMock), \
          patch("fabledassistant.services.push.send_push_notification", new_callable=AsyncMock):
 

tests/test_calendar_tool_tz.py

@@ -0,0 +1,134 @@
+"""Regression tests: calendar tool respects the user's configured timezone."""
+
+from datetime import timezone
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_create_event_all_day_bare_date_interprets_local_midnight():
+    """Bare date like '2026-09-30' for a NY user = 2026-09-30 00:00 NY,
+    stored as 2026-09-30 04:00 UTC — NOT 2026-09-30 00:00 UTC (which would
+    be 2026-09-29 19:00 NY and land on the wrong day)."""
+    from fabledassistant.services.tools.calendar import create_event_tool
+
+    captured = {}
+
+    async def fake_create_event(**kwargs):
+        captured.update(kwargs)
+        event = AsyncMock()
+        event.to_dict.return_value = {"id": 1, **{k: v for k, v in kwargs.items() if not callable(v)}}
+        return event
+
+    with patch(
+        "fabledassistant.services.tools.calendar.get_user_tz",
+        AsyncMock(return_value=__import__("zoneinfo").ZoneInfo("America/New_York")),
+    ), patch(
+        "fabledassistant.services.tools.calendar.events_create_event",
+        side_effect=fake_create_event,
+    ):
+        result = await create_event_tool(
+            user_id=1,
+            arguments={"title": "Birthday", "start": "2026-09-30"},
+        )
+
+    assert result["success"] is True
+    start_dt = captured["start_dt"]
+    assert start_dt.tzinfo is not None
+    # Converted to UTC: 00:00 NY (EDT, UTC-4) == 04:00 UTC on the same day
+    utc = start_dt.astimezone(timezone.utc)
+    assert (utc.year, utc.month, utc.day) == (2026, 9, 30)
+    assert utc.hour == 4  # EDT offset; would be 5 in EST
+    assert captured["all_day"] is True
+
+
+@pytest.mark.asyncio
+async def test_create_event_naive_datetime_is_user_local():
+    """'2026-03-15T14:30' for a NY user means 2:30pm NY, not 2:30pm UTC."""
+    from fabledassistant.services.tools.calendar import create_event_tool
+
+    captured = {}
+
+    async def fake_create_event(**kwargs):
+        captured.update(kwargs)
+        event = AsyncMock()
+        event.to_dict.return_value = {"id": 1}
+        return event
+
+    with patch(
+        "fabledassistant.services.tools.calendar.get_user_tz",
+        AsyncMock(return_value=__import__("zoneinfo").ZoneInfo("America/New_York")),
+    ), patch(
+        "fabledassistant.services.tools.calendar.events_create_event",
+        side_effect=fake_create_event,
+    ):
+        await create_event_tool(
+            user_id=1,
+            arguments={"title": "Meeting", "start": "2026-03-15T14:30"},
+        )
+
+    utc = captured["start_dt"].astimezone(timezone.utc)
+    # 14:30 NY on 2026-03-15 (after DST start) = 18:30 UTC
+    assert (utc.year, utc.month, utc.day, utc.hour, utc.minute) == (2026, 3, 15, 18, 30)
+
+
+@pytest.mark.asyncio
+async def test_create_event_explicit_offset_is_respected():
+    """Model-supplied timezone offsets must not be overridden by user TZ."""
+    from fabledassistant.services.tools.calendar import create_event_tool
+
+    captured = {}
+
+    async def fake_create_event(**kwargs):
+        captured.update(kwargs)
+        event = AsyncMock()
+        event.to_dict.return_value = {"id": 1}
+        return event
+
+    with patch(
+        "fabledassistant.services.tools.calendar.get_user_tz",
+        AsyncMock(return_value=__import__("zoneinfo").ZoneInfo("America/New_York")),
+    ), patch(
+        "fabledassistant.services.tools.calendar.events_create_event",
+        side_effect=fake_create_event,
+    ):
+        await create_event_tool(
+            user_id=1,
+            arguments={"title": "Meeting", "start": "2026-03-15T14:30+00:00"},
+        )
+
+    utc = captured["start_dt"].astimezone(timezone.utc)
+    assert (utc.hour, utc.minute) == (14, 30)
+
+
+@pytest.mark.asyncio
+async def test_list_events_bare_date_range_covers_local_day():
+    """date_from/date_to as bare dates should cover the full LOCAL day."""
+    from fabledassistant.services.tools.calendar import list_events_tool
+
+    captured = {}
+
+    async def fake_list_events(*, user_id, date_from, date_to):
+        captured["date_from"] = date_from
+        captured["date_to"] = date_to
+        return []
+
+    with patch(
+        "fabledassistant.services.tools.calendar.get_user_tz",
+        AsyncMock(return_value=__import__("zoneinfo").ZoneInfo("America/New_York")),
+    ), patch(
+        "fabledassistant.services.tools.calendar.events_list_events",
+        side_effect=fake_list_events,
+    ):
+        await list_events_tool(
+            user_id=1,
+            arguments={"date_from": "2026-09-30", "date_to": "2026-09-30"},
+        )
+
+    df = captured["date_from"].astimezone(timezone.utc)
+    dt = captured["date_to"].astimezone(timezone.utc)
+    # 2026-09-30 00:00 NY (EDT) = 04:00 UTC same day
+    assert (df.year, df.month, df.day, df.hour) == (2026, 9, 30, 4)
+    # 2026-09-30 23:59:59 NY (EDT) = 03:59:59 UTC next day
+    assert (dt.year, dt.month, dt.day, dt.hour) == (2026, 10, 1, 3)

tests/test_events_service.py

@@ -127,8 +127,10 @@ async def test_update_event_fires_caldav_push():
 @pytest.mark.asyncio
 async def test_tools_calendar_always_available():
     """Calendar tools must appear in get_tools_for_user even without CalDAV."""
-    with patch("fabledassistant.services.tools.is_caldav_configured", new_callable=AsyncMock) as mock_configured:
+    with patch("fabledassistant.services.tools._registry.is_caldav_configured", new_callable=AsyncMock) as mock_configured, \
+         patch("fabledassistant.services.settings.get_setting", new_callable=AsyncMock) as mock_setting:
         mock_configured.return_value = False
+        mock_setting.return_value = "false"
         from fabledassistant.services.tools import get_tools_for_user
         tools = await get_tools_for_user(user_id=1)
         tool_names = {t["function"]["name"] for t in tools}